strafe_type/float/constraint/
finite.rs1use std::fmt::{Debug, Display, Formatter};
2
3use num_traits::{FromPrimitive, ToPrimitive};
4
5use crate::float::constraint::float_constraint::FloatConstraint;
6
7#[derive(Debug, Copy, Clone)]
8pub struct Finite<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint>(T);
9
10impl<T> Display for Finite<T>
11where
12 T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint + Display,
13{
14 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
15 Display::fmt(&self.0, f)
16 }
17}
18
19impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> FloatConstraint
20 for Finite<T>
21{
22 #[inline]
23 fn get_f64(&self) -> f64 {
24 self.0.get_f64()
25 }
26
27 #[inline]
28 fn constraint(&self) -> bool {
29 self.0.constraint() && self.0.get_f64().is_finite()
30 }
31}
32
33impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<isize>
34 for Finite<T>
35{
36 #[inline]
37 fn from(n: isize) -> Self {
38 Self::from_isize(n).unwrap()
39 }
40}
41
42impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&isize>
43 for Finite<T>
44{
45 #[inline]
46 fn from(n: &isize) -> Self {
47 Self::from_isize(*n).unwrap()
48 }
49}
50
51impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut isize>
52 for Finite<T>
53{
54 #[inline]
55 fn from(n: &mut isize) -> Self {
56 Self::from_isize(*n).unwrap()
57 }
58}
59
60impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
61 for isize
62{
63 #[inline]
64 fn from(n: Finite<T>) -> Self {
65 n.to_isize().unwrap()
66 }
67}
68
69impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i8>
70 for Finite<T>
71{
72 #[inline]
73 fn from(n: i8) -> Self {
74 Self::from_i8(n).unwrap()
75 }
76}
77
78impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i8>
79 for Finite<T>
80{
81 #[inline]
82 fn from(n: &i8) -> Self {
83 Self::from_i8(*n).unwrap()
84 }
85}
86
87impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i8>
88 for Finite<T>
89{
90 #[inline]
91 fn from(n: &mut i8) -> Self {
92 Self::from_i8(*n).unwrap()
93 }
94}
95
96impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
97 for i8
98{
99 #[inline]
100 fn from(n: Finite<T>) -> Self {
101 n.to_i8().unwrap()
102 }
103}
104
105impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i16>
106 for Finite<T>
107{
108 #[inline]
109 fn from(n: i16) -> Self {
110 Self::from_i16(n).unwrap()
111 }
112}
113
114impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i16>
115 for Finite<T>
116{
117 #[inline]
118 fn from(n: &i16) -> Self {
119 Self::from_i16(*n).unwrap()
120 }
121}
122
123impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i16>
124 for Finite<T>
125{
126 #[inline]
127 fn from(n: &mut i16) -> Self {
128 Self::from_i16(*n).unwrap()
129 }
130}
131
132impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
133 for i16
134{
135 #[inline]
136 fn from(n: Finite<T>) -> Self {
137 n.to_i16().unwrap()
138 }
139}
140
141impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i32>
142 for Finite<T>
143{
144 #[inline]
145 fn from(n: i32) -> Self {
146 Self::from_i32(n).unwrap()
147 }
148}
149
150impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i32>
151 for Finite<T>
152{
153 #[inline]
154 fn from(n: &i32) -> Self {
155 Self::from_i32(*n).unwrap()
156 }
157}
158
159impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i32>
160 for Finite<T>
161{
162 #[inline]
163 fn from(n: &mut i32) -> Self {
164 Self::from_i32(*n).unwrap()
165 }
166}
167
168impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
169 for i32
170{
171 #[inline]
172 fn from(n: Finite<T>) -> Self {
173 n.to_i32().unwrap()
174 }
175}
176
177impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i64>
178 for Finite<T>
179{
180 #[inline]
181 fn from(n: i64) -> Self {
182 Self::from_i64(n).unwrap()
183 }
184}
185
186impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i64>
187 for Finite<T>
188{
189 #[inline]
190 fn from(n: &i64) -> Self {
191 Self::from_i64(*n).unwrap()
192 }
193}
194
195impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i64>
196 for Finite<T>
197{
198 #[inline]
199 fn from(n: &mut i64) -> Self {
200 Self::from_i64(*n).unwrap()
201 }
202}
203
204impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
205 for i64
206{
207 #[inline]
208 fn from(n: Finite<T>) -> Self {
209 n.to_i64().unwrap()
210 }
211}
212
213impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<i128>
214 for Finite<T>
215{
216 #[inline]
217 fn from(n: i128) -> Self {
218 Self::from_i128(n).unwrap()
219 }
220}
221
222impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&i128>
223 for Finite<T>
224{
225 #[inline]
226 fn from(n: &i128) -> Self {
227 Self::from_i128(*n).unwrap()
228 }
229}
230
231impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut i128>
232 for Finite<T>
233{
234 #[inline]
235 fn from(n: &mut i128) -> Self {
236 Self::from_i128(*n).unwrap()
237 }
238}
239
240impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
241 for i128
242{
243 #[inline]
244 fn from(n: Finite<T>) -> Self {
245 n.to_i128().unwrap()
246 }
247}
248
249impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<usize>
250 for Finite<T>
251{
252 #[inline]
253 fn from(n: usize) -> Self {
254 Self::from_usize(n).unwrap()
255 }
256}
257
258impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&usize>
259 for Finite<T>
260{
261 #[inline]
262 fn from(n: &usize) -> Self {
263 Self::from_usize(*n).unwrap()
264 }
265}
266
267impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut usize>
268 for Finite<T>
269{
270 #[inline]
271 fn from(n: &mut usize) -> Self {
272 Self::from_usize(*n).unwrap()
273 }
274}
275
276impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
277 for usize
278{
279 #[inline]
280 fn from(n: Finite<T>) -> Self {
281 n.to_usize().unwrap()
282 }
283}
284
285impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u8>
286 for Finite<T>
287{
288 #[inline]
289 fn from(n: u8) -> Self {
290 Self::from_u8(n).unwrap()
291 }
292}
293
294impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u8>
295 for Finite<T>
296{
297 #[inline]
298 fn from(n: &u8) -> Self {
299 Self::from_u8(*n).unwrap()
300 }
301}
302
303impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u8>
304 for Finite<T>
305{
306 #[inline]
307 fn from(n: &mut u8) -> Self {
308 Self::from_u8(*n).unwrap()
309 }
310}
311
312impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
313 for u8
314{
315 #[inline]
316 fn from(n: Finite<T>) -> Self {
317 n.to_u8().unwrap()
318 }
319}
320
321impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u16>
322 for Finite<T>
323{
324 #[inline]
325 fn from(n: u16) -> Self {
326 Self::from_u16(n).unwrap()
327 }
328}
329
330impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u16>
331 for Finite<T>
332{
333 #[inline]
334 fn from(n: &u16) -> Self {
335 Self::from_u16(*n).unwrap()
336 }
337}
338
339impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u16>
340 for Finite<T>
341{
342 #[inline]
343 fn from(n: &mut u16) -> Self {
344 Self::from_u16(*n).unwrap()
345 }
346}
347
348impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
349 for u16
350{
351 #[inline]
352 fn from(n: Finite<T>) -> Self {
353 n.to_u16().unwrap()
354 }
355}
356
357impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u32>
358 for Finite<T>
359{
360 #[inline]
361 fn from(n: u32) -> Self {
362 Self::from_u32(n).unwrap()
363 }
364}
365
366impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u32>
367 for Finite<T>
368{
369 #[inline]
370 fn from(n: &u32) -> Self {
371 Self::from_u32(*n).unwrap()
372 }
373}
374
375impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u32>
376 for Finite<T>
377{
378 #[inline]
379 fn from(n: &mut u32) -> Self {
380 Self::from_u32(*n).unwrap()
381 }
382}
383
384impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
385 for u32
386{
387 #[inline]
388 fn from(n: Finite<T>) -> Self {
389 n.to_u32().unwrap()
390 }
391}
392
393impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u64>
394 for Finite<T>
395{
396 #[inline]
397 fn from(n: u64) -> Self {
398 Self::from_u64(n).unwrap()
399 }
400}
401
402impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u64>
403 for Finite<T>
404{
405 #[inline]
406 fn from(n: &u64) -> Self {
407 Self::from_u64(*n).unwrap()
408 }
409}
410
411impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u64>
412 for Finite<T>
413{
414 #[inline]
415 fn from(n: &mut u64) -> Self {
416 Self::from_u64(*n).unwrap()
417 }
418}
419
420impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
421 for u64
422{
423 #[inline]
424 fn from(n: Finite<T>) -> Self {
425 n.to_u64().unwrap()
426 }
427}
428
429impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<u128>
430 for Finite<T>
431{
432 #[inline]
433 fn from(n: u128) -> Self {
434 Self::from_u128(n).unwrap()
435 }
436}
437
438impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&u128>
439 for Finite<T>
440{
441 #[inline]
442 fn from(n: &u128) -> Self {
443 Self::from_u128(*n).unwrap()
444 }
445}
446
447impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut u128>
448 for Finite<T>
449{
450 #[inline]
451 fn from(n: &mut u128) -> Self {
452 Self::from_u128(*n).unwrap()
453 }
454}
455
456impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
457 for u128
458{
459 #[inline]
460 fn from(n: Finite<T>) -> Self {
461 n.to_u128().unwrap()
462 }
463}
464
465impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<f32>
466 for Finite<T>
467{
468 #[inline]
469 fn from(n: f32) -> Self {
470 Self::from_f32(n).unwrap()
471 }
472}
473
474impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&f32>
475 for Finite<T>
476{
477 #[inline]
478 fn from(n: &f32) -> Self {
479 Self::from_f32(*n).unwrap()
480 }
481}
482
483impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut f32>
484 for Finite<T>
485{
486 #[inline]
487 fn from(n: &mut f32) -> Self {
488 Self::from_f32(*n).unwrap()
489 }
490}
491
492impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
493 for f32
494{
495 #[inline]
496 fn from(n: Finite<T>) -> Self {
497 n.to_f32().unwrap()
498 }
499}
500
501impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<f64>
502 for Finite<T>
503{
504 #[inline]
505 fn from(n: f64) -> Self {
506 Self::from_f64(n).unwrap()
507 }
508}
509
510impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&f64>
511 for Finite<T>
512{
513 #[inline]
514 fn from(n: &f64) -> Self {
515 Self::from_f64(*n).unwrap()
516 }
517}
518
519impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<&mut f64>
520 for Finite<T>
521{
522 #[inline]
523 fn from(n: &mut f64) -> Self {
524 Self::from_f64(*n).unwrap()
525 }
526}
527
528impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> From<Finite<T>>
529 for f64
530{
531 #[inline]
532 fn from(n: Finite<T>) -> Self {
533 n.to_f64().unwrap()
534 }
535}
536
537impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> ToPrimitive
538 for Finite<T>
539{
540 #[inline]
541 fn to_isize(&self) -> Option<isize> {
542 self.0.to_isize()
543 }
544
545 #[inline]
546 fn to_i8(&self) -> Option<i8> {
547 self.0.to_i8()
548 }
549
550 #[inline]
551 fn to_i16(&self) -> Option<i16> {
552 self.0.to_i16()
553 }
554
555 #[inline]
556 fn to_i32(&self) -> Option<i32> {
557 self.0.to_i32()
558 }
559
560 #[inline]
561 fn to_i64(&self) -> Option<i64> {
562 self.0.to_i64()
563 }
564
565 #[inline]
566 fn to_i128(&self) -> Option<i128> {
567 self.0.to_i128()
568 }
569
570 #[inline]
571 fn to_usize(&self) -> Option<usize> {
572 self.0.to_usize()
573 }
574
575 #[inline]
576 fn to_u8(&self) -> Option<u8> {
577 self.0.to_u8()
578 }
579
580 #[inline]
581 fn to_u16(&self) -> Option<u16> {
582 self.0.to_u16()
583 }
584
585 #[inline]
586 fn to_u32(&self) -> Option<u32> {
587 self.0.to_u32()
588 }
589
590 #[inline]
591 fn to_u64(&self) -> Option<u64> {
592 self.0.to_u64()
593 }
594
595 #[inline]
596 fn to_u128(&self) -> Option<u128> {
597 self.0.to_u128()
598 }
599
600 #[inline]
601 fn to_f32(&self) -> Option<f32> {
602 self.0.to_f32()
603 }
604
605 #[inline]
606 fn to_f64(&self) -> Option<f64> {
607 self.0.to_f64()
608 }
609}
610
611impl<T: Debug + Copy + Clone + ToPrimitive + FromPrimitive + FloatConstraint> FromPrimitive
612 for Finite<T>
613{
614 #[inline]
615 fn from_isize(n: isize) -> Option<Self> {
616 let ret = T::from_isize(n).map(|t| Self(t));
617 #[cfg(debug_assertions)]
618 if !ret.clone().unwrap().constraint() {
619 panic!("Finite failed: {:?}", ret);
620 }
621 ret
622 }
623
624 #[inline]
625 fn from_i8(n: i8) -> Option<Self> {
626 let ret = T::from_i8(n).map(|t| Self(t));
627 #[cfg(debug_assertions)]
628 if !ret.clone().unwrap().constraint() {
629 panic!("Finite failed: {:?}", ret);
630 }
631 ret
632 }
633
634 #[inline]
635 fn from_i16(n: i16) -> Option<Self> {
636 let ret = T::from_i16(n).map(|t| Self(t));
637 #[cfg(debug_assertions)]
638 if !ret.clone().unwrap().constraint() {
639 panic!("Finite failed: {:?}", ret);
640 }
641 ret
642 }
643
644 #[inline]
645 fn from_i32(n: i32) -> Option<Self> {
646 let ret = T::from_i32(n).map(|t| Self(t));
647 #[cfg(debug_assertions)]
648 if !ret.clone().unwrap().constraint() {
649 panic!("Finite failed: {:?}", ret);
650 }
651 ret
652 }
653
654 #[inline]
655 fn from_i64(n: i64) -> Option<Self> {
656 let ret = T::from_i64(n).map(|t| Self(t));
657 #[cfg(debug_assertions)]
658 if !ret.clone().unwrap().constraint() {
659 panic!("Finite failed: {:?}", ret);
660 }
661 ret
662 }
663
664 #[inline]
665 fn from_i128(n: i128) -> Option<Self> {
666 let ret = T::from_i128(n).map(|t| Self(t));
667 #[cfg(debug_assertions)]
668 if !ret.clone().unwrap().constraint() {
669 panic!("Finite failed: {:?}", ret);
670 }
671 ret
672 }
673
674 #[inline]
675 fn from_usize(n: usize) -> Option<Self> {
676 let ret = T::from_usize(n).map(|t| Self(t));
677 #[cfg(debug_assertions)]
678 if !ret.clone().unwrap().constraint() {
679 panic!("Finite failed: {:?}", ret);
680 }
681 ret
682 }
683
684 #[inline]
685 fn from_u8(n: u8) -> Option<Self> {
686 let ret = T::from_u8(n).map(|t| Self(t));
687 #[cfg(debug_assertions)]
688 if !ret.clone().unwrap().constraint() {
689 panic!("Finite failed: {:?}", ret);
690 }
691 ret
692 }
693
694 #[inline]
695 fn from_u16(n: u16) -> Option<Self> {
696 let ret = T::from_u16(n).map(|t| Self(t));
697 #[cfg(debug_assertions)]
698 if !ret.clone().unwrap().constraint() {
699 panic!("Finite failed: {:?}", ret);
700 }
701 ret
702 }
703
704 #[inline]
705 fn from_u32(n: u32) -> Option<Self> {
706 let ret = T::from_u32(n).map(|t| Self(t));
707 #[cfg(debug_assertions)]
708 if !ret.clone().unwrap().constraint() {
709 panic!("Finite failed: {:?}", ret);
710 }
711 ret
712 }
713
714 #[inline]
715 fn from_u64(n: u64) -> Option<Self> {
716 let ret = T::from_u64(n).map(|t| Self(t));
717 #[cfg(debug_assertions)]
718 if !ret.clone().unwrap().constraint() {
719 panic!("Finite failed: {:?}", ret);
720 }
721 ret
722 }
723
724 #[inline]
725 fn from_u128(n: u128) -> Option<Self> {
726 let ret = T::from_u128(n).map(|t| Self(t));
727 #[cfg(debug_assertions)]
728 if !ret.clone().unwrap().constraint() {
729 panic!("Finite failed: {:?}", ret);
730 }
731 ret
732 }
733
734 #[inline]
735 fn from_f32(n: f32) -> Option<Self> {
736 let ret = T::from_f32(n).map(|t| Self(t));
737 #[cfg(debug_assertions)]
738 if !ret.clone().unwrap().constraint() {
739 panic!("Finite failed: {:?}", ret);
740 }
741 ret
742 }
743
744 #[inline]
745 fn from_f64(n: f64) -> Option<Self> {
746 let ret = T::from_f64(n).map(|t| Self(t));
747 #[cfg(debug_assertions)]
748 if !ret.clone().unwrap().constraint() {
749 panic!("Finite failed: {:?}", ret);
750 }
751 ret
752 }
753}