c_prime/
prim.rs

1use crate::ptrait::Primality;
2
3impl Primality for f64{
4  const ONE : Self = 1f64;
5  
6  const FIRST_PRIME : Self = -9007199254740881f64;
7  
8  const LAST_PRIME : Self = 9007199254740881f64;
9  
10  fn is_prime(&self) -> bool{
11    if *self > 9007199254740992f64{
12       panic!("Not representable as 64-bit IEEE-754 float")
13    }
14    machine_prime::is_prime(self.abs() as u64)   
15  }
16  
17  fn strong_case(&self) -> bool{
18  
19    if *self > 9007199254740992f64{
20       panic!("Not representable as 64-bit IEEE-754 float")
21    }
22    if *self == 1f64{
23       return false;
24    }
25    if (self.abs() as u64)&1 == 0{
26      return false
27    }
28    machine_prime::is_prime_wc(self.abs() as u64)
29  }
30}
31
32impl Primality for f32{
33  const ONE : Self = 1f32;
34  
35  const FIRST_PRIME : Self = -16777213f32;
36  
37  const LAST_PRIME : Self = 16777213f32;
38  
39  fn is_prime(&self) -> bool{
40    if *self > 16777216f32{
41       panic!("Not representable as 64-bit IEEE-754 float")
42    }
43    machine_prime::is_prime(self.abs() as u64)   
44  }
45  
46  fn strong_case(&self) -> bool{
47  
48    if *self > 16777216f32{
49       panic!("Not representable as 64-bit IEEE-754 float")
50    }
51    let n = self.abs() as u64;
52    if n == 1{
53       return false;
54    }
55    if n&1 == 0{
56      return false
57    }
58    machine_prime::is_prime_wc(n)
59  }
60}
61
62
63impl Primality for u64{
64
65  const ONE : Self = 0x1;
66  
67  const FIRST_PRIME : Self = 0x2;
68  
69  const LAST_PRIME : Self = 0xFFFFFFFFFFFFFFC5;
70  
71  fn is_prime(&self) -> bool{
72    machine_prime::is_prime(*self)   
73  }
74  
75  fn strong_case(&self) -> bool{
76    if *self&1 == 0{
77      return false
78    }
79    if *self==1{
80       return false
81    }
82    machine_prime::is_prime_wc(*self)
83  }
84}
85
86impl Primality for u128{
87
88  const ONE : Self = 0x1;
89  
90  const FIRST_PRIME : Self = 0x2;
91  
92  const LAST_PRIME : Self = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF61;
93  
94  fn is_prime(&self) -> bool{
95    machine_prime::is_prime_128(*self)   
96  }
97  
98  fn strong_case(&self) -> bool{
99    if *self&1 == 0{
100      return false
101    }
102    if *self==1{
103       return false
104    }
105    machine_prime::is_prime_wc_128(*self)
106  }
107}
108
109impl Primality for i128{
110
111  const ONE : Self = 0x1;
112  
113  const FIRST_PRIME : Self = -0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
114  
115  const LAST_PRIME : Self = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
116  
117  fn is_prime(&self) -> bool{
118    machine_prime::is_prime_128(self.unsigned_abs())   
119  }
120  
121  fn strong_case(&self) -> bool{
122    if *self&1 == 0{
123      return false
124    }
125    if *self==1{
126       return false
127    }
128    machine_prime::is_prime_wc_128(self.unsigned_abs())
129  }
130}
131
132impl Primality for usize{
133
134  const ONE : Self = 0x1;
135  
136  const FIRST_PRIME : Self = 0x2;
137  
138  const LAST_PRIME : Self = 0xFFFFFFFFFFFFFFC5;
139  
140  fn is_prime(&self) -> bool{
141    machine_prime::is_prime(*self as u64)   
142  }
143  
144  fn strong_case(&self) -> bool{
145    if *self&1 == 0{
146      return false
147    }
148    if *self==1{
149       return false
150    }
151    machine_prime::is_prime_wc(*self as u64)
152  }
153}
154
155impl Primality for u32{
156   const ONE : Self = 0x1;
157   const FIRST_PRIME : Self = 0x2;
158   const LAST_PRIME : Self = 0xFFFFFFFB;
159   
160   
161   fn is_prime(&self) -> bool{
162    machine_prime::is_prime(*self as u64)   
163  }
164  
165  fn strong_case(&self) -> bool{
166    if *self&1 == 0{
167      return false
168    }
169    
170    if *self==1{
171       return false
172    }
173    machine_prime::is_prime_wc(*self as u64)
174  }
175}
176
177
178impl Primality for u16{
179   const ONE : Self = 0x1;
180   const FIRST_PRIME : Self = 0x2;
181   const LAST_PRIME : Self = 0xFFF1;
182   
183   fn is_prime(&self) -> bool{
184    machine_prime::is_prime(*self as u64)   
185  }
186  
187  fn strong_case(&self) -> bool{
188    if *self&1 == 0{
189      return false
190    }
191    if *self==1{
192       return false
193    }
194    machine_prime::is_prime_wc(*self  as u64)
195  }
196}
197
198impl Primality for u8{
199   const ONE : Self = 0x1;
200   const FIRST_PRIME : Self = 0x2;
201   const LAST_PRIME : Self = 0xFB;
202   
203   
204   fn is_prime(&self) -> bool{
205    machine_prime::is_prime(*self as u64)   
206  }
207  
208  fn strong_case(&self) -> bool{
209    if *self&1 == 0{
210      return false
211    }
212    if *self==1{
213       return false
214    }
215    machine_prime::is_prime_wc(*self as u64)
216  }
217}
218
219impl Primality for i8{
220   const ONE : Self = 0x1;
221   const FIRST_PRIME : Self = -0x7F;
222   const LAST_PRIME : Self = 0x7F;
223   
224   
225   fn is_prime(&self) -> bool{
226    machine_prime::is_prime(self.unsigned_abs() as u64)   
227  }
228  
229  fn strong_case(&self) -> bool{
230    if *self&1 == 0{
231      return false
232    }
233    if *self==1{
234       return false
235    }
236    machine_prime::is_prime_wc(self.unsigned_abs() as u64)
237  }
238}
239
240impl Primality for i16{
241   const ONE : Self = 0x1;
242   const FIRST_PRIME : Self = -0x7FED;
243   const LAST_PRIME : Self = 0x7FED;
244   
245   
246   fn is_prime(&self) -> bool{
247    machine_prime::is_prime(self.unsigned_abs() as u64)   
248  }
249  
250  fn strong_case(&self) -> bool{
251    if *self&1 == 0{
252      return false
253    }
254    if *self==1{
255       return false
256    }
257    machine_prime::is_prime_wc(self.unsigned_abs() as u64)
258  }
259}
260
261impl Primality for i32{
262   const ONE : Self = 0x1;
263   const FIRST_PRIME : Self = -0x7FFFFFFF;
264   const LAST_PRIME : Self = 0x7FFFFFFF;
265   
266   
267   fn is_prime(&self) -> bool{
268    machine_prime::is_prime(self.unsigned_abs() as u64)   
269  }
270  
271  fn strong_case(&self) -> bool{
272    if *self&1 == 0{
273      return false
274    }
275    if *self==1{
276       return false
277    }
278    machine_prime::is_prime_wc(self.unsigned_abs() as u64)
279  }
280}
281
282impl Primality for i64{
283   const ONE : Self = 0x1;
284   const FIRST_PRIME : Self = -0x7FFFFFFFFFFFFFE7;
285   const LAST_PRIME : Self = 0x7FFFFFFFFFFFFFE7;
286   
287   fn is_prime(&self) -> bool{
288    machine_prime::is_prime(self.unsigned_abs())   
289  }
290  
291  fn strong_case(&self) -> bool{
292    if *self&1 == 0{
293      return false
294    }
295    if *self==1{
296       return false
297    }
298    machine_prime::is_prime_wc(self.unsigned_abs())
299  }
300}
301
302impl Primality for isize{
303   const ONE : Self = 0x1;
304   const FIRST_PRIME : Self = -0x7FFFFFFFFFFFFFE7;
305   const LAST_PRIME : Self = 0x7FFFFFFFFFFFFFE7;
306   
307   fn is_prime(&self) -> bool{
308    machine_prime::is_prime(self.unsigned_abs() as u64)   
309  }
310  
311  fn strong_case(&self) -> bool{
312    if *self&1 == 0{
313      return false
314    }
315    if *self==1{
316       return false
317    }
318    machine_prime::is_prime_wc(self.unsigned_abs() as u64)
319  }
320}
321
c_prime/prim.rs

c_prime/
prim.rs
