1use std::cmp::Ordering;
2use std::fmt::{Debug, Display, Formatter};
3use std::ops::{Add, Div, Mul, Neg, Sub};
4use std::time::{Duration, Instant};
5
6use chrono::NaiveDateTime;
7
8use crate::algebra::concept::{Infinity, NegativeInfinity, RealNumber, SemiArithmetic};
9use super::error::IllegalArgumentError;
10
11#[derive(Clone, Copy)]
12#[non_exhaustive]
13pub enum ValueWrapper<T> {
14 Value(T),
15 Inf,
16 NegInf,
17}
18
19impl<T> ValueWrapper<T> {
20 pub fn is_inf_or_neg_inf(&self) -> bool {
21 match self {
22 Self::Inf | Self::NegInf => true,
23 _ => false,
24 }
25 }
26}
27
28pub trait ValueWrapperUnwrap<T> {
29 fn unwrap(&self) -> &T;
30}
31
32impl<T> ValueWrapperUnwrap<T> for ValueWrapper<T> {
33 default fn unwrap(&self) -> &T {
34 match self {
35 Self::Value(value) => value,
36 Self::Inf => panic!("Cannot unwrap infinity value"),
37 Self::NegInf => panic!("Cannot unwrap negative infinity value"),
38 }
39 }
40}
41
42impl<T: RealNumber> ValueWrapperUnwrap<T> for ValueWrapper<T> {
43 fn unwrap(&self) -> &T {
44 match self {
45 Self::Value(value) => value,
46 Self::Inf => T::INF.as_ref().unwrap(),
47 Self::NegInf => T::NEG_INF.as_ref().unwrap(),
48 }
49 }
50}
51
52impl<T> From<Infinity> for ValueWrapper<T> {
53 fn from(_: Infinity) -> Self {
54 Self::Inf
55 }
56}
57
58impl<T> From<NegativeInfinity> for ValueWrapper<T> {
59 fn from(_: NegativeInfinity) -> Self {
60 Self::NegInf
61 }
62}
63
64impl<T: SemiArithmetic> From<T> for ValueWrapper<T> {
65 default fn from(value: T) -> Self {
66 Self::Value(value)
67 }
68}
69
70impl<T: RealNumber> From<T> for ValueWrapper<T> {
71 fn from(value: T) -> Self {
72 if value.is_inf() {
73 Self::Inf
74 } else if value.is_neg_inf() {
75 Self::NegInf
76 } else if value.is_nan() {
77 panic!("Illegal argument NaN for value range!!!")
78 } else {
79 Self::Value(value)
80 }
81 }
82}
83
84impl<T: for<'a> From<&'a U>, U> From<&ValueWrapper<U>> for ValueWrapper<T> {
85 fn from(value: &ValueWrapper<U>) -> Self {
86 match value {
87 ValueWrapper::Value(value) => ValueWrapper::Value(T::from(value)),
88 ValueWrapper::Inf => ValueWrapper::Inf,
89 ValueWrapper::NegInf => ValueWrapper::NegInf,
90 }
91 }
92}
93
94impl<T: Display> Display for ValueWrapper<T> {
95 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
96 match self {
97 Self::Value(value) => write!(f, "{}", value),
98 Self::Inf => write!(f, "inf"),
99 Self::NegInf => write!(f, "-inf"),
100 }
101 }
102}
103
104impl<T: Display> Debug for ValueWrapper<T> {
105 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
106 match self {
107 Self::Value(value) => write!(f, "{}", value),
108 Self::Inf => write!(f, "inf"),
109 Self::NegInf => write!(f, "-inf"),
110 }
111 }
112}
113
114impl<T, U: SemiArithmetic> PartialEq<U> for ValueWrapper<T>
115where
116 T: PartialEq<U>,
117{
118 default fn eq(&self, other: &U) -> bool {
119 match self {
120 ValueWrapper::Value(value) => value.eq(other),
121 ValueWrapper::Inf => false,
122 ValueWrapper::NegInf => false,
123 }
124 }
125}
126
127impl<T, U: RealNumber> PartialEq<U> for ValueWrapper<T>
128where
129 T: PartialEq<U>,
130{
131 fn eq(&self, other: &U) -> bool {
132 if other.is_nan() {
133 false
134 } else if other.is_inf() {
135 match self {
136 ValueWrapper::Value(_) | ValueWrapper::NegInf => false,
137 ValueWrapper::Inf => true,
138 }
139 } else if other.is_neg_inf() {
140 match self {
141 ValueWrapper::Value(_) | ValueWrapper::Inf => false,
142 ValueWrapper::NegInf => true,
143 }
144 } else {
145 match self {
146 ValueWrapper::Value(value) => value.eq(other),
147 ValueWrapper::Inf => false,
148 ValueWrapper::NegInf => false,
149 }
150 }
151 }
152}
153
154impl<T, U> PartialEq<ValueWrapper<U>> for ValueWrapper<T>
155where
156 T: PartialEq<U>,
157{
158 default fn eq(&self, other: &ValueWrapper<U>) -> bool {
159 match self {
160 ValueWrapper::Value(value) => match other {
161 ValueWrapper::Value(other_value) => value.eq(other_value),
162 _ => false,
163 },
164 ValueWrapper::Inf => match other {
165 ValueWrapper::Inf => true,
166 _ => false,
167 },
168 ValueWrapper::NegInf => match other {
169 ValueWrapper::NegInf => true,
170 _ => false,
171 },
172 }
173 }
174}
175
176impl<T, U: SemiArithmetic> PartialOrd<U> for ValueWrapper<T>
177where
178 T: PartialOrd<U>,
179{
180 default fn partial_cmp(&self, rhs: &U) -> Option<Ordering> {
181 match self {
182 ValueWrapper::Value(lhs_value) => lhs_value.partial_cmp(rhs),
183 ValueWrapper::Inf => Some(Ordering::Greater),
184 ValueWrapper::NegInf => Some(Ordering::Less),
185 }
186 }
187}
188
189impl<T, U: RealNumber> PartialOrd<U> for ValueWrapper<T>
190where
191 T: PartialOrd<U>,
192{
193 fn partial_cmp(&self, rhs: &U) -> Option<Ordering> {
194 if rhs.is_nan() {
195 None
196 } else if rhs.is_inf() {
197 match self {
198 ValueWrapper::Value(_) | ValueWrapper::NegInf => Some(Ordering::Less),
199 ValueWrapper::Inf => Some(Ordering::Equal),
200 }
201 } else if rhs.is_neg_inf() {
202 match self {
203 ValueWrapper::Value(_) | ValueWrapper::Inf => Some(Ordering::Greater),
204 ValueWrapper::NegInf => Some(Ordering::Equal),
205 }
206 } else {
207 match self {
208 ValueWrapper::Value(lhs_value) => lhs_value.partial_cmp(rhs),
209 ValueWrapper::Inf => Some(Ordering::Greater),
210 ValueWrapper::NegInf => Some(Ordering::Less),
211 }
212 }
213 }
214}
215
216impl<T, U> PartialOrd<ValueWrapper<U>> for ValueWrapper<T>
217where
218 T: PartialOrd<U>,
219{
220 default fn partial_cmp(&self, rhs: &ValueWrapper<U>) -> Option<Ordering> {
221 match self {
222 ValueWrapper::Value(lhs_value) => match rhs {
223 ValueWrapper::Value(rhs_value) => lhs_value.partial_cmp(rhs_value),
224 ValueWrapper::Inf => Some(Ordering::Less),
225 ValueWrapper::NegInf => Some(Ordering::Greater),
226 },
227 ValueWrapper::Inf => match rhs {
228 ValueWrapper::Value(_) | ValueWrapper::NegInf => Some(Ordering::Greater),
229 ValueWrapper::Inf => Some(Ordering::Equal),
230 },
231 ValueWrapper::NegInf => match rhs {
232 ValueWrapper::Value(_) | ValueWrapper::Inf => Some(Ordering::Less),
233 ValueWrapper::NegInf => Some(Ordering::Equal),
234 },
235 }
236 }
237}
238
239macro_rules! value_wrapper_template {
240 ($type:ident, $rhs:ident) => {
241 impl From<$type> for ValueWrapper<$type> {
242 fn from(value: $type) -> Self {
243 Self::Value(value)
244 }
245 }
246
247 impl<'a> From<&'a $type> for ValueWrapper<$type> {
248 fn from(value: &'a $type) -> Self {
249 Self::Value(*value)
250 }
251 }
252
253 impl PartialEq<$type> for ValueWrapper<$type> {
254 fn eq(&self, other: &$type) -> bool {
255 match self {
256 Self::Value(value) => value == other,
257 ValueWrapper::Inf => false,
258 ValueWrapper::NegInf => false,
259 }
260 }
261 }
262
263 impl PartialOrd<$type> for ValueWrapper<$type> {
264 fn partial_cmp(&self, rhs: &$type) -> Option<Ordering> {
265 match self {
266 ValueWrapper::Value(value) => value.partial_cmp(rhs),
267 ValueWrapper::Inf => Some(Ordering::Less),
268 ValueWrapper::NegInf => Some(Ordering::Greater),
269 }
270 }
271 }
272
273 impl Add<$rhs> for ValueWrapper<$type> {
274 type Output = Result<ValueWrapper<<$type as Add<$rhs>>::Output>, IllegalArgumentError>;
275
276 fn add(self, rhs: $rhs) -> Self::Output {
277 match self {
278 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value + rhs)),
279 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
280 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
281 }
282 }
283 }
284
285 impl<'a> Add<&'a $rhs> for ValueWrapper<$type> {
286 type Output = Result<ValueWrapper<<$type as Add<$rhs>>::Output>, IllegalArgumentError>;
287
288 fn add(self, rhs: &'a $rhs) -> Self::Output {
289 match self {
290 ValueWrapper::Value(lhs_value) => {
291 Ok(ValueWrapper::from(lhs_value + rhs.clone()))
292 }
293 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
294 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
295 }
296 }
297 }
298
299 impl<'a> Add<$rhs> for &'a ValueWrapper<$type> {
300 type Output = Result<ValueWrapper<<$type as Add<$rhs>>::Output>, IllegalArgumentError>;
301
302 fn add(self, rhs: $rhs) -> Self::Output {
303 match self {
304 ValueWrapper::Value(lhs_value) => {
305 Ok(ValueWrapper::from(lhs_value.clone() + rhs))
306 }
307 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
308 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
309 }
310 }
311 }
312
313 impl<'a, 'b> Add<&'b $rhs> for &'a ValueWrapper<$type> {
314 type Output = Result<ValueWrapper<<$type as Add<$rhs>>::Output>, IllegalArgumentError>;
315
316 fn add(self, rhs: &'b $rhs) -> Self::Output {
317 match self {
318 ValueWrapper::Value(lhs_value) => {
319 Ok(ValueWrapper::from(lhs_value.clone() + rhs.clone()))
320 }
321 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
322 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
323 }
324 }
325 }
326
327 impl Sub<$rhs> for ValueWrapper<$type> {
328 type Output = Result<ValueWrapper<<$type as Sub<$rhs>>::Output>, IllegalArgumentError>;
329
330 fn sub(self, rhs: $rhs) -> Self::Output {
331 match self {
332 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value - rhs)),
333 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
334 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
335 }
336 }
337 }
338
339 impl<'a> Sub<&'a $rhs> for ValueWrapper<$type> {
340 type Output = Result<ValueWrapper<<$type as Sub<$rhs>>::Output>, IllegalArgumentError>;
341
342 fn sub(self, rhs: &'a $rhs) -> Self::Output {
343 match self {
344 ValueWrapper::Value(lhs_value) => {
345 Ok(ValueWrapper::from(lhs_value - rhs.clone()))
346 }
347 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
348 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
349 }
350 }
351 }
352
353 impl<'a> Sub<$rhs> for &'a ValueWrapper<$type> {
354 type Output = Result<ValueWrapper<<$type as Sub<$rhs>>::Output>, IllegalArgumentError>;
355
356 fn sub(self, rhs: $rhs) -> Self::Output {
357 match self {
358 ValueWrapper::Value(lhs_value) => {
359 Ok(ValueWrapper::from(lhs_value.clone() - rhs))
360 }
361 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
362 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
363 }
364 }
365 }
366
367 impl<'a, 'b> Sub<&'b $rhs> for &'a ValueWrapper<$type> {
368 type Output = Result<ValueWrapper<<$type as Sub<$rhs>>::Output>, IllegalArgumentError>;
369
370 fn sub(self, rhs: &'b $rhs) -> Self::Output {
371 match self {
372 ValueWrapper::Value(lhs_value) => {
373 Ok(ValueWrapper::from(lhs_value.clone() - rhs.clone()))
374 }
375 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
376 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
377 }
378 }
379 }
380 };
381}
382value_wrapper_template!(Instant, Duration);
383value_wrapper_template!(NaiveDateTime, Duration);
384value_wrapper_template!(Duration, Duration);
385
386macro_rules! signed_value_wrapper_template {
387 ($($type:ident)*) => ($(
388 impl Neg for ValueWrapper<$type> {
389 type Output = Result<ValueWrapper<<$type as Neg>::Output>, IllegalArgumentError>;
390
391 fn neg(self) -> Self::Output {
392 match self {
393 ValueWrapper::Value(value) => Ok(ValueWrapper::from(-value)),
394 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
395 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
396 }
397 }
398 }
399
400 impl<'a> Neg for &'a ValueWrapper<$type> {
401 type Output = Result<ValueWrapper<<&'a $type as Neg>::Output>, IllegalArgumentError>;
402
403 fn neg(self) -> Self::Output {
404 match self {
405 ValueWrapper::Value(value) => Ok(ValueWrapper::from(-value)),
406 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
407 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
408 }
409 }
410 }
411 )*)
412}
413signed_value_wrapper_template! { i8 i16 i32 i64 i128 isize f32 f64 }
414
415macro_rules! real_number_value_wrapper_template {
416 ($($type:ident)*) => ($(
417 impl Add<$type> for ValueWrapper<$type> {
418 type Output = Result<ValueWrapper<<$type as Add<$type>>::Output>, IllegalArgumentError>;
419
420 fn add(self, rhs: $type) -> Self::Output {
421 if rhs.is_nan() {
422 Err(IllegalArgumentError {
423 msg: "Illegal argument NaN for value range!!!".to_string(),
424 })
425 } else if rhs.is_inf() {
426 match self {
427 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
428 ValueWrapper::NegInf => Err(IllegalArgumentError {
429 msg: "invalid addition between inf and -inf!!!".to_string(),
430 }),
431 }
432 } else if rhs.is_neg_inf() {
433 match self {
434 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
435 ValueWrapper::Inf => Err(IllegalArgumentError {
436 msg: "invalid addition between inf and -inf!!!".to_string(),
437 }),
438 }
439 } else {
440 match self {
441 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value + rhs)),
442 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
443 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
444 }
445 }
446 }
447 }
448
449 impl<'a> Add<&'a $type> for ValueWrapper<$type> {
450 type Output = Result<ValueWrapper<<$type as Add<&'a $type>>::Output>, IllegalArgumentError>;
451
452 fn add(self, rhs: &'a $type) -> Self::Output {
453 if rhs.is_nan() {
454 Err(IllegalArgumentError {
455 msg: "Illegal argument NaN for value range!!!".to_string(),
456 })
457 } else if rhs.is_inf() {
458 match self {
459 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
460 ValueWrapper::NegInf => Err(IllegalArgumentError {
461 msg: "invalid addition between inf and -inf!!!".to_string(),
462 }),
463 }
464 } else if rhs.is_neg_inf() {
465 match self {
466 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
467 ValueWrapper::Inf => Err(IllegalArgumentError {
468 msg: "invalid addition between inf and -inf!!!".to_string(),
469 }),
470 }
471 } else {
472 match self {
473 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value + rhs)),
474 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
475 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
476 }
477 }
478 }
479 }
480
481 impl<'a> Add<$type> for &'a ValueWrapper<$type> {
482 type Output = Result<ValueWrapper<<&'a $type as Add<$type>>::Output>, IllegalArgumentError>;
483
484 fn add(self, rhs: $type) -> Self::Output {
485 if rhs.is_nan() {
486 Err(IllegalArgumentError {
487 msg: "Illegal argument NaN for value range!!!".to_string(),
488 })
489 } else if rhs.is_inf() {
490 match self {
491 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
492 ValueWrapper::NegInf => Err(IllegalArgumentError {
493 msg: "invalid addition between inf and -inf!!!".to_string(),
494 }),
495 }
496 } else if rhs.is_neg_inf() {
497 match self {
498 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
499 ValueWrapper::Inf => Err(IllegalArgumentError {
500 msg: "invalid addition between inf and -inf!!!".to_string(),
501 }),
502 }
503 } else {
504 match self {
505 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value + rhs)),
506 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
507 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
508 }
509 }
510 }
511 }
512
513 impl<'a, 'b> Add<&'b $type> for &'a ValueWrapper<$type> {
514 type Output = Result<ValueWrapper<<&'a $type as Add<&'b $type>>::Output>, IllegalArgumentError>;
515
516 fn add(self, rhs: &'b $type) -> Self::Output {
517 if rhs.is_nan() {
518 Err(IllegalArgumentError {
519 msg: "Illegal argument NaN for value range!!!".to_string(),
520 })
521 } else if rhs.is_inf() {
522 match self {
523 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
524 ValueWrapper::NegInf => Err(IllegalArgumentError {
525 msg: "invalid addition between inf and -inf!!!".to_string(),
526 }),
527 }
528 } else if rhs.is_neg_inf() {
529 match self {
530 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
531 ValueWrapper::Inf => Err(IllegalArgumentError {
532 msg: "invalid addition between inf and -inf!!!".to_string(),
533 }),
534 }
535 } else {
536 match self {
537 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value + rhs)),
538 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
539 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
540 }
541 }
542 }
543 }
544
545 impl Add<ValueWrapper<$type>> for $type {
546 type Output = Result<ValueWrapper<<$type as Add<$type>>::Output>, IllegalArgumentError>;
547
548 fn add(self, rhs: ValueWrapper<$type>) -> Self::Output {
549 if self.is_nan() {
550 Err(IllegalArgumentError {
551 msg: "Illegal argument NaN for value range!!!".to_string(),
552 })
553 } else if self.is_inf() {
554 match rhs {
555 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
556 ValueWrapper::NegInf => Err(IllegalArgumentError {
557 msg: "invalid addition between inf and -inf!!!".to_string(),
558 }),
559 }
560 } else if self.is_neg_inf() {
561 match rhs {
562 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
563 ValueWrapper::Inf => Err(IllegalArgumentError {
564 msg: "invalid addition between inf and -inf!!!".to_string(),
565 }),
566 }
567 } else {
568 match rhs {
569 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self + rhs_value)),
570 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
571 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
572 }
573 }
574 }
575 }
576
577 impl<'a> Add<&'a ValueWrapper<$type>> for $type {
578 type Output = Result<ValueWrapper<<$type as Add<&'a $type>>::Output>, IllegalArgumentError>;
579
580 fn add(self, rhs: &'a ValueWrapper<$type>) -> Self::Output {
581 if self.is_nan() {
582 Err(IllegalArgumentError {
583 msg: "Illegal argument NaN for value range!!!".to_string(),
584 })
585 } else if self.is_inf() {
586 match rhs {
587 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
588 ValueWrapper::NegInf => Err(IllegalArgumentError {
589 msg: "invalid addition between inf and -inf!!!".to_string(),
590 }),
591 }
592 } else if self.is_neg_inf() {
593 match rhs {
594 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
595 ValueWrapper::Inf => Err(IllegalArgumentError {
596 msg: "invalid addition between inf and -inf!!!".to_string(),
597 }),
598 }
599 } else {
600 match rhs {
601 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self + rhs_value)),
602 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
603 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
604 }
605 }
606 }
607 }
608
609 impl<'a> Add<ValueWrapper<$type>> for &'a $type {
610 type Output = Result<ValueWrapper<<&'a $type as Add<$type>>::Output>, IllegalArgumentError>;
611
612 fn add(self, rhs: ValueWrapper<$type>) -> Self::Output {
613 if self.is_nan() {
614 Err(IllegalArgumentError {
615 msg: "Illegal argument NaN for value range!!!".to_string(),
616 })
617 } else if self.is_inf() {
618 match rhs {
619 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
620 ValueWrapper::NegInf => Err(IllegalArgumentError {
621 msg: "invalid addition between inf and -inf!!!".to_string(),
622 }),
623 }
624 } else if self.is_neg_inf() {
625 match rhs {
626 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
627 ValueWrapper::Inf => Err(IllegalArgumentError {
628 msg: "invalid addition between inf and -inf!!!".to_string(),
629 }),
630 }
631 } else {
632 match rhs {
633 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self + rhs_value)),
634 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
635 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
636 }
637 }
638 }
639 }
640
641 impl<'a, 'b> Add<&'b ValueWrapper<$type>> for &'a $type {
642 type Output = Result<ValueWrapper<<&'a $type as Add<&'b $type>>::Output>, IllegalArgumentError>;
643
644 fn add(self, rhs: &'b ValueWrapper<$type>) -> Self::Output {
645 if self.is_nan() {
646 Err(IllegalArgumentError {
647 msg: "Illegal argument NaN for value range!!!".to_string(),
648 })
649 } else if self.is_inf() {
650 match rhs {
651 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
652 ValueWrapper::NegInf => Err(IllegalArgumentError {
653 msg: "invalid addition between inf and -inf!!!".to_string(),
654 }),
655 }
656 } else if self.is_neg_inf() {
657 match rhs {
658 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
659 ValueWrapper::Inf => Err(IllegalArgumentError {
660 msg: "invalid addition between inf and -inf!!!".to_string(),
661 }),
662 }
663 } else {
664 match rhs {
665 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self + rhs_value)),
666 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
667 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
668 }
669 }
670 }
671 }
672
673 impl Add<ValueWrapper<$type>> for ValueWrapper<$type> {
674 type Output = Result<ValueWrapper<<$type as Add<$type>>::Output>, IllegalArgumentError>;
675
676 fn add(self, rhs: ValueWrapper<$type>) -> Self::Output {
677 match self {
678 ValueWrapper::Value(lhs_value) => match rhs {
679 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value + rhs_value)),
680 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
681 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
682 },
683 ValueWrapper::Inf => match rhs {
684 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
685 ValueWrapper::NegInf => Err(IllegalArgumentError {
686 msg: "invalid addition between inf and -inf!!!".to_string(),
687 }),
688 },
689 ValueWrapper::NegInf => match rhs {
690 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
691 ValueWrapper::Inf => Err(IllegalArgumentError {
692 msg: "invalid addition between inf and -inf!!!".to_string(),
693 }),
694 },
695 }
696 }
697 }
698
699 impl<'a> Add<&'a ValueWrapper<$type>> for ValueWrapper<$type> {
700 type Output = Result<ValueWrapper<<$type as Add<&'a $type>>::Output>, IllegalArgumentError>;
701
702 fn add(self, rhs: &'a ValueWrapper<$type>) -> Self::Output {
703 match self {
704 ValueWrapper::Value(lhs_value) => match rhs {
705 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value + rhs_value)),
706 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
707 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
708 },
709 ValueWrapper::Inf => match rhs {
710 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
711 ValueWrapper::NegInf => Err(IllegalArgumentError {
712 msg: "invalid addition between inf and -inf!!!".to_string(),
713 }),
714 },
715 ValueWrapper::NegInf => match rhs {
716 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
717 ValueWrapper::Inf => Err(IllegalArgumentError {
718 msg: "invalid addition between inf and -inf!!!".to_string(),
719 }),
720 },
721 }
722 }
723 }
724
725 impl<'a> Add<ValueWrapper<$type>> for &'a ValueWrapper<$type> {
726 type Output = Result<ValueWrapper<<&'a $type as Add<$type>>::Output>, IllegalArgumentError>;
727
728 fn add(self, rhs: ValueWrapper<$type>) -> Self::Output {
729 match self {
730 ValueWrapper::Value(lhs_value) => match rhs {
731 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value + rhs_value)),
732 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
733 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
734 },
735 ValueWrapper::Inf => match rhs {
736 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
737 ValueWrapper::NegInf => Err(IllegalArgumentError {
738 msg: "invalid addition between inf and -inf!!!".to_string(),
739 }),
740 },
741 ValueWrapper::NegInf => match rhs {
742 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
743 ValueWrapper::Inf => Err(IllegalArgumentError {
744 msg: "invalid addition between inf and -inf!!!".to_string(),
745 }),
746 },
747 }
748 }
749 }
750
751 impl<'a, 'b> Add<&'b ValueWrapper<$type>> for &'a ValueWrapper<$type> {
752 type Output = Result<ValueWrapper<<&'a $type as Add<&'b $type>>::Output>, IllegalArgumentError>;
753
754 fn add(self, rhs: &'b ValueWrapper<$type>) -> Self::Output {
755 match self {
756 ValueWrapper::Value(lhs_value) => match rhs {
757 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value + rhs_value)),
758 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
759 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
760 },
761 ValueWrapper::Inf => match rhs {
762 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
763 ValueWrapper::NegInf => Err(IllegalArgumentError {
764 msg: "invalid addition between inf and -inf!!!".to_string(),
765 }),
766 },
767 ValueWrapper::NegInf => match rhs {
768 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
769 ValueWrapper::Inf => Err(IllegalArgumentError {
770 msg: "invalid addition between inf and -inf!!!".to_string(),
771 }),
772 },
773 }
774 }
775 }
776
777 impl Sub<$type> for ValueWrapper<$type> {
778 type Output = Result<ValueWrapper<<$type as Sub<$type>>::Output>, IllegalArgumentError>;
779
780 fn sub(self, rhs: $type) -> Self::Output {
781 if rhs.is_nan() {
782 Err(IllegalArgumentError {
783 msg: "Illegal argument NaN for value range!!!".to_string(),
784 })
785 } else if rhs.is_inf() {
786 match self {
787 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
788 ValueWrapper::Inf => Err(IllegalArgumentError {
789 msg: "invalid subtraction between inf and inf!!!".to_string(),
790 }),
791 }
792 } else if rhs.is_neg_inf() {
793 match self {
794 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
795 ValueWrapper::NegInf => Err(IllegalArgumentError {
796 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
797 }),
798 }
799 } else {
800 match self {
801 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value - rhs)),
802 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
803 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
804 }
805 }
806 }
807 }
808
809 impl<'a> Sub<&'a $type> for ValueWrapper<$type> {
810 type Output = Result<ValueWrapper<<$type as Sub<&'a $type>>::Output>, IllegalArgumentError>;
811
812 fn sub(self, rhs: &'a $type) -> Self::Output {
813 if rhs.is_nan() {
814 Err(IllegalArgumentError {
815 msg: "Illegal argument NaN for value range!!!".to_string(),
816 })
817 } else if rhs.is_inf() {
818 match self {
819 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
820 ValueWrapper::Inf => Err(IllegalArgumentError {
821 msg: "invalid subtraction between inf and inf!!!".to_string(),
822 }),
823 }
824 } else if rhs.is_neg_inf() {
825 match self {
826 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
827 ValueWrapper::NegInf => Err(IllegalArgumentError {
828 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
829 }),
830 }
831 } else {
832 match self {
833 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value - rhs)),
834 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
835 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
836 }
837 }
838 }
839 }
840
841 impl<'a> Sub<$type> for &'a ValueWrapper<$type> {
842 type Output = Result<ValueWrapper<<&'a $type as Sub<$type>>::Output>, IllegalArgumentError>;
843
844 fn sub(self, rhs: $type) -> Self::Output {
845 if rhs.is_nan() {
846 Err(IllegalArgumentError {
847 msg: "Illegal argument NaN for value range!!!".to_string(),
848 })
849 } else if rhs.is_inf() {
850 match self {
851 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
852 ValueWrapper::Inf => Err(IllegalArgumentError {
853 msg: "invalid subtraction between inf and inf!!!".to_string(),
854 }),
855 }
856 } else if rhs.is_neg_inf() {
857 match self {
858 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
859 ValueWrapper::NegInf => Err(IllegalArgumentError {
860 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
861 }),
862 }
863 } else {
864 match self {
865 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value - rhs)),
866 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
867 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
868 }
869 }
870 }
871 }
872
873 impl<'a, 'b> Sub<&'b $type> for &'a ValueWrapper<$type> {
874 type Output = Result<ValueWrapper<<&'a $type as Sub<&'b $type>>::Output>, IllegalArgumentError>;
875
876 fn sub(self, rhs: &'b $type) -> Self::Output {
877 if rhs.is_nan() {
878 Err(IllegalArgumentError {
879 msg: "Illegal argument NaN for value range!!!".to_string(),
880 })
881 } else if rhs.is_inf() {
882 match self {
883 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
884 ValueWrapper::Inf => Err(IllegalArgumentError {
885 msg: "invalid subtraction between inf and inf!!!".to_string(),
886 }),
887 }
888 } else if rhs.is_neg_inf() {
889 match self {
890 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
891 ValueWrapper::NegInf => Err(IllegalArgumentError {
892 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
893 }),
894 }
895 } else {
896 match self {
897 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value - rhs)),
898 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
899 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
900 }
901 }
902 }
903 }
904
905 impl Sub<ValueWrapper<$type>> for $type {
906 type Output = Result<ValueWrapper<<$type as Sub<$type>>::Output>, IllegalArgumentError>;
907
908 fn sub(self, rhs: ValueWrapper<$type>) -> Self::Output {
909 if self.is_nan() {
910 Err(IllegalArgumentError {
911 msg: "Illegal argument NaN for value range!!!".to_string(),
912 })
913 } else if self.is_inf() {
914 match rhs {
915 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
916 ValueWrapper::Inf => Err(IllegalArgumentError {
917 msg: "invalid subtraction between inf and inf!!!".to_string(),
918 }),
919 }
920 } else if self.is_neg_inf() {
921 match rhs {
922 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
923 ValueWrapper::NegInf => Err(IllegalArgumentError {
924 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
925 }),
926 }
927 } else {
928 match rhs {
929 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self - rhs_value)),
930 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
931 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
932 }
933 }
934 }
935 }
936
937 impl<'a> Sub<&'a ValueWrapper<$type>> for $type {
938 type Output = Result<ValueWrapper<<$type as Sub<&'a $type>>::Output>, IllegalArgumentError>;
939
940 fn sub(self, rhs: &'a ValueWrapper<$type>) -> Self::Output {
941 if self.is_nan() {
942 Err(IllegalArgumentError {
943 msg: "Illegal argument NaN for value range!!!".to_string(),
944 })
945 } else if self.is_inf() {
946 match rhs {
947 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
948 ValueWrapper::Inf => Err(IllegalArgumentError {
949 msg: "invalid subtraction between inf and inf!!!".to_string(),
950 }),
951 }
952 } else if self.is_neg_inf() {
953 match rhs {
954 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
955 ValueWrapper::NegInf => Err(IllegalArgumentError {
956 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
957 }),
958 }
959 } else {
960 match rhs {
961 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self - rhs_value)),
962 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
963 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
964 }
965 }
966 }
967 }
968
969 impl<'a> Sub<ValueWrapper<$type>> for &'a $type {
970 type Output = Result<ValueWrapper<<&'a $type as Sub<$type>>::Output>, IllegalArgumentError>;
971
972 fn sub(self, rhs: ValueWrapper<$type>) -> Self::Output {
973 if self.is_nan() {
974 Err(IllegalArgumentError {
975 msg: "Illegal argument NaN for value range!!!".to_string(),
976 })
977 } else if self.is_inf() {
978 match rhs {
979 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
980 ValueWrapper::Inf => Err(IllegalArgumentError {
981 msg: "invalid subtraction between inf and inf!!!".to_string(),
982 }),
983 }
984 } else if self.is_neg_inf() {
985 match rhs {
986 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
987 ValueWrapper::NegInf => Err(IllegalArgumentError {
988 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
989 }),
990 }
991 } else {
992 match rhs {
993 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self - rhs_value)),
994 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
995 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
996 }
997 }
998 }
999 }
1000
1001 impl<'a, 'b> Sub<&'b ValueWrapper<$type>> for &'a $type {
1002 type Output = Result<ValueWrapper<<&'a $type as Sub<&'b $type>>::Output>, IllegalArgumentError>;
1003
1004 fn sub(self, rhs: &'b ValueWrapper<$type>) -> Self::Output {
1005 if self.is_nan() {
1006 Err(IllegalArgumentError {
1007 msg: "Illegal argument NaN for value range!!!".to_string(),
1008 })
1009 } else if self.is_inf() {
1010 match rhs {
1011 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1012 ValueWrapper::Inf => Err(IllegalArgumentError {
1013 msg: "invalid subtraction between inf and inf!!!".to_string(),
1014 }),
1015 }
1016 } else if self.is_neg_inf() {
1017 match rhs {
1018 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1019 ValueWrapper::NegInf => Err(IllegalArgumentError {
1020 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
1021 }),
1022 }
1023 } else {
1024 match rhs {
1025 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self - rhs_value)),
1026 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1027 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1028 }
1029 }
1030 }
1031 }
1032
1033 impl Sub<ValueWrapper<$type>> for ValueWrapper<$type> {
1034 type Output = Result<ValueWrapper<<$type as Sub<$type>>::Output>, IllegalArgumentError>;
1035
1036 fn sub(self, rhs: ValueWrapper<$type>) -> Self::Output {
1037 match self {
1038 ValueWrapper::Value(lhs_value) => match rhs {
1039 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value - rhs_value)),
1040 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1041 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1042 },
1043 ValueWrapper::Inf => match rhs {
1044 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1045 ValueWrapper::Inf => Err(IllegalArgumentError {
1046 msg: "invalid subtraction between inf and inf!!!".to_string(),
1047 }),
1048 },
1049 ValueWrapper::NegInf => match rhs {
1050 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1051 ValueWrapper::NegInf => Err(IllegalArgumentError {
1052 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
1053 }),
1054 },
1055 }
1056 }
1057 }
1058
1059 impl<'a> Sub<&'a ValueWrapper<$type>> for ValueWrapper<$type> {
1060 type Output = Result<ValueWrapper<<$type as Sub<&'a $type>>::Output>, IllegalArgumentError>;
1061
1062 fn sub(self, rhs: &'a ValueWrapper<$type>) -> Self::Output {
1063 match self {
1064 ValueWrapper::Value(lhs_value) => match rhs {
1065 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value - rhs_value)),
1066 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1067 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1068 },
1069 ValueWrapper::Inf => match rhs {
1070 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1071 ValueWrapper::Inf => Err(IllegalArgumentError {
1072 msg: "invalid subtraction between inf and inf!!!".to_string(),
1073 }),
1074 },
1075 ValueWrapper::NegInf => match rhs {
1076 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1077 ValueWrapper::NegInf => Err(IllegalArgumentError {
1078 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
1079 }),
1080 },
1081 }
1082 }
1083 }
1084
1085 impl<'a> Sub<ValueWrapper<$type>> for &'a ValueWrapper<$type> {
1086 type Output = Result<ValueWrapper<<$type as Sub<&'a $type>>::Output>, IllegalArgumentError>;
1087
1088 fn sub(self, rhs: ValueWrapper<$type>) -> Self::Output {
1089 match self {
1090 ValueWrapper::Value(lhs_value) => match rhs {
1091 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value - rhs_value)),
1092 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1093 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1094 },
1095 ValueWrapper::Inf => match rhs {
1096 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1097 ValueWrapper::Inf => Err(IllegalArgumentError {
1098 msg: "invalid subtraction between inf and inf!!!".to_string(),
1099 }),
1100 },
1101 ValueWrapper::NegInf => match rhs {
1102 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1103 ValueWrapper::NegInf => Err(IllegalArgumentError {
1104 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
1105 }),
1106 },
1107 }
1108 }
1109 }
1110
1111 impl<'a, 'b> Sub<&'b ValueWrapper<$type>> for &'a ValueWrapper<$type> {
1112 type Output = Result<ValueWrapper<<&'a $type as Sub<&'b $type>>::Output>, IllegalArgumentError>;
1113
1114 fn sub(self, rhs: &'b ValueWrapper<$type>) -> Self::Output {
1115 match self {
1116 ValueWrapper::Value(lhs_value) => match rhs {
1117 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value - rhs_value)),
1118 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1119 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1120 },
1121 ValueWrapper::Inf => match rhs {
1122 ValueWrapper::Value(_) | ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1123 ValueWrapper::Inf => Err(IllegalArgumentError {
1124 msg: "invalid subtraction between inf and inf!!!".to_string(),
1125 }),
1126 },
1127 ValueWrapper::NegInf => match rhs {
1128 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1129 ValueWrapper::NegInf => Err(IllegalArgumentError {
1130 msg: "invalid subtraction between -inf and -inf!!!".to_string(),
1131 }),
1132 },
1133 }
1134 }
1135 }
1136
1137 impl Mul<$type> for ValueWrapper<$type> {
1138 type Output = Result<ValueWrapper<<$type as Mul<$type>>::Output>, IllegalArgumentError>;
1139
1140 fn mul(self, rhs: $type) -> Self::Output {
1141 if rhs.is_nan() {
1142 Err(IllegalArgumentError {
1143 msg: "Illegal argument NaN for value range!!!".to_string(),
1144 })
1145 } else if rhs.is_inf() {
1146 match self {
1147 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1148 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1149 }
1150 } else if rhs.is_neg_inf() {
1151 match self {
1152 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1153 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1154 }
1155 } else {
1156 match self {
1157 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value * rhs)),
1158 ValueWrapper::Inf => {
1159 if &rhs >= $type::ZERO {
1160 Ok(ValueWrapper::Inf)
1161 } else {
1162 Ok(ValueWrapper::NegInf)
1163 }
1164 }
1165 ValueWrapper::NegInf => {
1166 if &rhs >= $type::ZERO {
1167 Ok(ValueWrapper::NegInf)
1168 } else {
1169 Ok(ValueWrapper::Inf)
1170 }
1171 }
1172 }
1173 }
1174 }
1175 }
1176
1177 impl<'a> Mul<&'a $type> for ValueWrapper<$type> {
1178 type Output = Result<ValueWrapper<<$type as Mul<&'a $type>>::Output>, IllegalArgumentError>;
1179
1180 fn mul(self, rhs: &'a $type) -> Self::Output {
1181 if rhs.is_nan() {
1182 Err(IllegalArgumentError {
1183 msg: "Illegal argument NaN for value range!!!".to_string(),
1184 })
1185 } else if rhs.is_inf() {
1186 match self {
1187 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1188 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1189 }
1190 } else if rhs.is_neg_inf() {
1191 match self {
1192 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1193 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1194 }
1195 } else {
1196 match self {
1197 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value * rhs)),
1198 ValueWrapper::Inf => {
1199 if rhs >= $type::ZERO {
1200 Ok(ValueWrapper::Inf)
1201 } else {
1202 Ok(ValueWrapper::NegInf)
1203 }
1204 }
1205 ValueWrapper::NegInf => {
1206 if rhs >= $type::ZERO {
1207 Ok(ValueWrapper::NegInf)
1208 } else {
1209 Ok(ValueWrapper::Inf)
1210 }
1211 }
1212 }
1213 }
1214 }
1215 }
1216
1217 impl<'a> Mul<$type> for ValueWrapper<&'a $type> {
1218 type Output = Result<ValueWrapper<<&'a $type as Mul<$type>>::Output>, IllegalArgumentError>;
1219
1220 fn mul(self, rhs: $type) -> Self::Output {
1221 if rhs.is_nan() {
1222 Err(IllegalArgumentError {
1223 msg: "Illegal argument NaN for value range!!!".to_string(),
1224 })
1225 } else if rhs.is_inf() {
1226 match self {
1227 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1228 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1229 }
1230 } else if rhs.is_neg_inf() {
1231 match self {
1232 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1233 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1234 }
1235 } else {
1236 match self {
1237 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value * rhs)),
1238 ValueWrapper::Inf => {
1239 if &rhs >= $type::ZERO {
1240 Ok(ValueWrapper::Inf)
1241 } else {
1242 Ok(ValueWrapper::NegInf)
1243 }
1244 }
1245 ValueWrapper::NegInf => {
1246 if &rhs >= $type::ZERO {
1247 Ok(ValueWrapper::NegInf)
1248 } else {
1249 Ok(ValueWrapper::Inf)
1250 }
1251 }
1252 }
1253 }
1254 }
1255 }
1256
1257 impl<'a, 'b> Mul<&'b $type> for &'a ValueWrapper<$type> {
1258 type Output = Result<ValueWrapper<<&'a $type as Mul<&'b $type>>::Output>, IllegalArgumentError>;
1259
1260 fn mul(self, rhs: &'b $type) -> Self::Output {
1261 if rhs.is_nan() {
1262 Err(IllegalArgumentError {
1263 msg: "Illegal argument NaN for value range!!!".to_string(),
1264 })
1265 } else if rhs.is_inf() {
1266 match self {
1267 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1268 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1269 }
1270 } else if rhs.is_neg_inf() {
1271 match self {
1272 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1273 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1274 }
1275 } else {
1276 match self {
1277 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value * rhs)),
1278 ValueWrapper::Inf => {
1279 if rhs >= $type::ZERO {
1280 Ok(ValueWrapper::Inf)
1281 } else {
1282 Ok(ValueWrapper::NegInf)
1283 }
1284 }
1285 ValueWrapper::NegInf => {
1286 if rhs >= $type::ZERO {
1287 Ok(ValueWrapper::NegInf)
1288 } else {
1289 Ok(ValueWrapper::Inf)
1290 }
1291 }
1292 }
1293 }
1294 }
1295 }
1296
1297 impl Mul<ValueWrapper<$type>> for $type {
1298 type Output = Result<ValueWrapper<<$type as Mul<$type>>::Output>, IllegalArgumentError>;
1299
1300 fn mul(self, rhs: ValueWrapper<$type>) -> Self::Output {
1301 if self.is_nan() {
1302 Err(IllegalArgumentError {
1303 msg: "Illegal argument NaN for value range!!!".to_string(),
1304 })
1305 } else if self.is_inf() {
1306 match rhs {
1307 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1308 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1309 }
1310 } else if self.is_neg_inf() {
1311 match rhs {
1312 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1313 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1314 }
1315 } else {
1316 match rhs {
1317 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self * rhs_value)),
1318 ValueWrapper::Inf => {
1319 if &self >= $type::ZERO {
1320 Ok(ValueWrapper::Inf)
1321 } else {
1322 Ok(ValueWrapper::NegInf)
1323 }
1324 }
1325 ValueWrapper::NegInf => {
1326 if &self >= $type::ZERO {
1327 Ok(ValueWrapper::NegInf)
1328 } else {
1329 Ok(ValueWrapper::Inf)
1330 }
1331 }
1332 }
1333 }
1334 }
1335 }
1336
1337 impl<'a> Mul<&'a ValueWrapper<$type>> for $type {
1338 type Output = Result<ValueWrapper<<$type as Mul<&'a $type>>::Output>, IllegalArgumentError>;
1339
1340 fn mul(self, rhs: &'a ValueWrapper<$type>) -> Self::Output {
1341 if self.is_nan() {
1342 Err(IllegalArgumentError {
1343 msg: "Illegal argument NaN for value range!!!".to_string(),
1344 })
1345 } else if self.is_inf() {
1346 match rhs {
1347 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1348 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1349 }
1350 } else if self.is_neg_inf() {
1351 match rhs {
1352 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1353 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1354 }
1355 } else {
1356 match rhs {
1357 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self * rhs_value)),
1358 ValueWrapper::Inf => {
1359 if &self >= $type::ZERO {
1360 Ok(ValueWrapper::Inf)
1361 } else {
1362 Ok(ValueWrapper::NegInf)
1363 }
1364 }
1365 ValueWrapper::NegInf => {
1366 if &self >= $type::ZERO {
1367 Ok(ValueWrapper::NegInf)
1368 } else {
1369 Ok(ValueWrapper::Inf)
1370 }
1371 }
1372 }
1373 }
1374 }
1375 }
1376
1377 impl<'a> Mul<ValueWrapper<$type>> for &'a $type {
1378 type Output = Result<ValueWrapper<<$type as Mul<&'a $type>>::Output>, IllegalArgumentError>;
1379
1380 fn mul(self, rhs: ValueWrapper<$type>) -> Self::Output {
1381 if self.is_nan() {
1382 Err(IllegalArgumentError {
1383 msg: "Illegal argument NaN for value range!!!".to_string(),
1384 })
1385 } else if self.is_inf() {
1386 match rhs {
1387 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1388 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1389 }
1390 } else if self.is_neg_inf() {
1391 match rhs {
1392 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1393 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1394 }
1395 } else {
1396 match rhs {
1397 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self * rhs_value)),
1398 ValueWrapper::Inf => {
1399 if self >= $type::ZERO {
1400 Ok(ValueWrapper::Inf)
1401 } else {
1402 Ok(ValueWrapper::NegInf)
1403 }
1404 }
1405 ValueWrapper::NegInf => {
1406 if self >= $type::ZERO {
1407 Ok(ValueWrapper::NegInf)
1408 } else {
1409 Ok(ValueWrapper::Inf)
1410 }
1411 }
1412 }
1413 }
1414 }
1415 }
1416
1417 impl<'a, 'b> Mul<&'b ValueWrapper<$type>> for &'a $type {
1418 type Output = Result<ValueWrapper<<&'a $type as Mul<&'b $type>>::Output>, IllegalArgumentError>;
1419
1420 fn mul(self, rhs: &'b ValueWrapper<$type>) -> Self::Output {
1421 if self.is_nan() {
1422 Err(IllegalArgumentError {
1423 msg: "Illegal argument NaN for value range!!!".to_string(),
1424 })
1425 } else if self.is_inf() {
1426 match rhs {
1427 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1428 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1429 }
1430 } else if self.is_neg_inf() {
1431 match rhs {
1432 ValueWrapper::Value(_) | ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1433 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1434 }
1435 } else {
1436 match rhs {
1437 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self * rhs_value)),
1438 ValueWrapper::Inf => {
1439 if self >= $type::ZERO {
1440 Ok(ValueWrapper::Inf)
1441 } else {
1442 Ok(ValueWrapper::NegInf)
1443 }
1444 }
1445 ValueWrapper::NegInf => {
1446 if self >= $type::ZERO {
1447 Ok(ValueWrapper::NegInf)
1448 } else {
1449 Ok(ValueWrapper::Inf)
1450 }
1451 }
1452 }
1453 }
1454 }
1455 }
1456
1457 impl Mul<ValueWrapper<$type>> for ValueWrapper<$type> {
1458 type Output = Result<ValueWrapper<<$type as Mul<$type>>::Output>, IllegalArgumentError>;
1459
1460 fn mul(self, rhs: ValueWrapper<$type>) -> Self::Output {
1461 match self {
1462 ValueWrapper::Value(lhs_value) => match rhs {
1463 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value * rhs_value)),
1464 ValueWrapper::Inf => {
1465 if &lhs_value >= $type::ZERO {
1466 Ok(ValueWrapper::Inf)
1467 } else {
1468 Ok(ValueWrapper::NegInf)
1469 }
1470 }
1471 ValueWrapper::NegInf => {
1472 if &lhs_value >= $type::ZERO {
1473 Ok(ValueWrapper::NegInf)
1474 } else {
1475 Ok(ValueWrapper::Inf)
1476 }
1477 }
1478 },
1479 ValueWrapper::Inf => match rhs {
1480 ValueWrapper::Value(rhs_value) => {
1481 if &rhs_value >= $type::ZERO {
1482 Ok(ValueWrapper::Inf)
1483 } else {
1484 Ok(ValueWrapper::NegInf)
1485 }
1486 }
1487 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1488 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1489 },
1490 ValueWrapper::NegInf => match rhs {
1491 ValueWrapper::Value(rhs_value) => {
1492 if &rhs_value >= $type::ZERO {
1493 Ok(ValueWrapper::NegInf)
1494 } else {
1495 Ok(ValueWrapper::Inf)
1496 }
1497 }
1498 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1499 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1500 },
1501 }
1502 }
1503 }
1504
1505 impl<'a> Mul<&'a ValueWrapper<$type>> for ValueWrapper<$type> {
1506 type Output = Result<ValueWrapper<<$type as Mul<&'a $type>>::Output>, IllegalArgumentError>;
1507
1508 fn mul(self, rhs: &'a ValueWrapper<$type>) -> Self::Output {
1509 match self {
1510 ValueWrapper::Value(lhs_value) => match rhs {
1511 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value * rhs_value)),
1512 ValueWrapper::Inf => {
1513 if &lhs_value >= $type::ZERO {
1514 Ok(ValueWrapper::Inf)
1515 } else {
1516 Ok(ValueWrapper::NegInf)
1517 }
1518 }
1519 ValueWrapper::NegInf => {
1520 if &lhs_value >= $type::ZERO {
1521 Ok(ValueWrapper::NegInf)
1522 } else {
1523 Ok(ValueWrapper::Inf)
1524 }
1525 }
1526 },
1527 ValueWrapper::Inf => match rhs {
1528 ValueWrapper::Value(rhs_value) => {
1529 if rhs_value >= $type::ZERO {
1530 Ok(ValueWrapper::Inf)
1531 } else {
1532 Ok(ValueWrapper::NegInf)
1533 }
1534 }
1535 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1536 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1537 },
1538 ValueWrapper::NegInf => match rhs {
1539 ValueWrapper::Value(rhs_value) => {
1540 if rhs_value >= $type::ZERO {
1541 Ok(ValueWrapper::NegInf)
1542 } else {
1543 Ok(ValueWrapper::Inf)
1544 }
1545 }
1546 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1547 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1548 },
1549 }
1550 }
1551 }
1552
1553 impl<'a> Mul<ValueWrapper<$type>> for &'a ValueWrapper<$type> {
1554 type Output = Result<ValueWrapper<<$type as Mul<&'a $type>>::Output>, IllegalArgumentError>;
1555
1556 fn mul(self, rhs: ValueWrapper<$type>) -> Self::Output {
1557 match self {
1558 ValueWrapper::Value(lhs_value) => match rhs {
1559 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value * rhs_value)),
1560 ValueWrapper::Inf => {
1561 if lhs_value >= $type::ZERO {
1562 Ok(ValueWrapper::Inf)
1563 } else {
1564 Ok(ValueWrapper::NegInf)
1565 }
1566 }
1567 ValueWrapper::NegInf => {
1568 if lhs_value >= $type::ZERO {
1569 Ok(ValueWrapper::NegInf)
1570 } else {
1571 Ok(ValueWrapper::Inf)
1572 }
1573 }
1574 },
1575 ValueWrapper::Inf => match rhs {
1576 ValueWrapper::Value(rhs_value) => {
1577 if &rhs_value >= $type::ZERO {
1578 Ok(ValueWrapper::Inf)
1579 } else {
1580 Ok(ValueWrapper::NegInf)
1581 }
1582 }
1583 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1584 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1585 },
1586 ValueWrapper::NegInf => match rhs {
1587 ValueWrapper::Value(rhs_value) => {
1588 if &rhs_value >= $type::ZERO {
1589 Ok(ValueWrapper::NegInf)
1590 } else {
1591 Ok(ValueWrapper::Inf)
1592 }
1593 }
1594 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1595 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1596 },
1597 }
1598 }
1599 }
1600
1601 impl<'a, 'b> Mul<&'b ValueWrapper<$type>> for &'a ValueWrapper<$type> {
1602 type Output = Result<ValueWrapper<<&'a $type as Mul<&'b $type>>::Output>, IllegalArgumentError>;
1603
1604 fn mul(self, rhs: &'b ValueWrapper<$type>) -> Self::Output {
1605 match self {
1606 ValueWrapper::Value(lhs_value) => match rhs {
1607 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value * rhs_value)),
1608 ValueWrapper::Inf => {
1609 if lhs_value >= $type::ZERO {
1610 Ok(ValueWrapper::Inf)
1611 } else {
1612 Ok(ValueWrapper::NegInf)
1613 }
1614 }
1615 ValueWrapper::NegInf => {
1616 if lhs_value >= $type::ZERO {
1617 Ok(ValueWrapper::NegInf)
1618 } else {
1619 Ok(ValueWrapper::Inf)
1620 }
1621 }
1622 },
1623 ValueWrapper::Inf => match rhs {
1624 ValueWrapper::Value(rhs_value) => {
1625 if rhs_value >= $type::ZERO {
1626 Ok(ValueWrapper::Inf)
1627 } else {
1628 Ok(ValueWrapper::NegInf)
1629 }
1630 }
1631 ValueWrapper::Inf => Ok(ValueWrapper::Inf),
1632 ValueWrapper::NegInf => Ok(ValueWrapper::NegInf),
1633 },
1634 ValueWrapper::NegInf => match rhs {
1635 ValueWrapper::Value(rhs_value) => {
1636 if rhs_value >= $type::ZERO {
1637 Ok(ValueWrapper::NegInf)
1638 } else {
1639 Ok(ValueWrapper::Inf)
1640 }
1641 }
1642 ValueWrapper::Inf => Ok(ValueWrapper::NegInf),
1643 ValueWrapper::NegInf => Ok(ValueWrapper::Inf),
1644 },
1645 }
1646 }
1647 }
1648
1649 impl Div<$type> for ValueWrapper<$type> {
1650 type Output = Result<ValueWrapper<<$type as Div<$type>>::Output>, IllegalArgumentError>;
1651
1652 fn div(self, rhs: $type) -> Self::Output {
1653 if rhs.is_nan() {
1654 Err(IllegalArgumentError {
1655 msg: "Illegal argument NaN for value range!!!".to_string(),
1656 })
1657 } else if rhs.is_inf() {
1658 match self {
1659 ValueWrapper::Value(_) => {
1660 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1661 }
1662 ValueWrapper::Inf => Err(IllegalArgumentError {
1663 msg: "Invalid div between inf and inf!!!".to_string(),
1664 }),
1665 ValueWrapper::NegInf => Err(IllegalArgumentError {
1666 msg: "Invalid div between -inf and inf!!!".to_string(),
1667 }),
1668 }
1669 } else if rhs.is_neg_inf() {
1670 match self {
1671 ValueWrapper::Value(_) => {
1672 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1673 }
1674 ValueWrapper::Inf => Err(IllegalArgumentError {
1675 msg: "Invalid div between inf and -inf!!!".to_string(),
1676 }),
1677 ValueWrapper::NegInf => Err(IllegalArgumentError {
1678 msg: "Invalid div between -inf and -inf!!!".to_string(),
1679 }),
1680 }
1681 } else {
1682 match self {
1683 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value / rhs)),
1684 ValueWrapper::Inf => {
1685 if &rhs >= $type::ZERO {
1686 Ok(ValueWrapper::Inf)
1687 } else {
1688 Ok(ValueWrapper::NegInf)
1689 }
1690 }
1691 ValueWrapper::NegInf => {
1692 if &rhs >= $type::ZERO {
1693 Ok(ValueWrapper::NegInf)
1694 } else {
1695 Ok(ValueWrapper::Inf)
1696 }
1697 }
1698 }
1699 }
1700 }
1701 }
1702
1703 impl<'a> Div<&'a $type> for ValueWrapper<$type> {
1704 type Output = Result<ValueWrapper<<$type as Div<&'a $type>>::Output>, IllegalArgumentError>;
1705
1706 fn div(self, rhs: &'a $type) -> Self::Output {
1707 if rhs.is_nan() {
1708 Err(IllegalArgumentError {
1709 msg: "Illegal argument NaN for value range!!!".to_string(),
1710 })
1711 } else if rhs.is_inf() {
1712 match self {
1713 ValueWrapper::Value(_) => {
1714 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1715 }
1716 ValueWrapper::Inf => Err(IllegalArgumentError {
1717 msg: "Invalid div between inf and inf!!!".to_string(),
1718 }),
1719 ValueWrapper::NegInf => Err(IllegalArgumentError {
1720 msg: "Invalid div between -inf and inf!!!".to_string(),
1721 }),
1722 }
1723 } else if rhs.is_neg_inf() {
1724 match self {
1725 ValueWrapper::Value(_) => {
1726 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1727 }
1728 ValueWrapper::Inf => Err(IllegalArgumentError {
1729 msg: "Invalid div between inf and -inf!!!".to_string(),
1730 }),
1731 ValueWrapper::NegInf => Err(IllegalArgumentError {
1732 msg: "Invalid div between -inf and -inf!!!".to_string(),
1733 }),
1734 }
1735 } else {
1736 match self {
1737 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value / rhs)),
1738 ValueWrapper::Inf => {
1739 if rhs >= $type::ZERO {
1740 Ok(ValueWrapper::Inf)
1741 } else {
1742 Ok(ValueWrapper::NegInf)
1743 }
1744 }
1745 ValueWrapper::NegInf => {
1746 if rhs >= $type::ZERO {
1747 Ok(ValueWrapper::NegInf)
1748 } else {
1749 Ok(ValueWrapper::Inf)
1750 }
1751 }
1752 }
1753 }
1754 }
1755 }
1756
1757 impl<'a> Div<$type> for &'a ValueWrapper<$type> {
1758 type Output = Result<ValueWrapper<<&'a $type as Div<$type>>::Output>, IllegalArgumentError>;
1759
1760 fn div(self, rhs: $type) -> Self::Output {
1761 if rhs.is_nan() {
1762 Err(IllegalArgumentError {
1763 msg: "Illegal argument NaN for value range!!!".to_string(),
1764 })
1765 } else if rhs.is_inf() {
1766 match self {
1767 ValueWrapper::Value(_) => {
1768 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1769 }
1770 ValueWrapper::Inf => Err(IllegalArgumentError {
1771 msg: "Invalid div between inf and inf!!!".to_string(),
1772 }),
1773 ValueWrapper::NegInf => Err(IllegalArgumentError {
1774 msg: "Invalid div between -inf and inf!!!".to_string(),
1775 }),
1776 }
1777 } else if rhs.is_neg_inf() {
1778 match self {
1779 ValueWrapper::Value(_) => {
1780 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1781 }
1782 ValueWrapper::Inf => Err(IllegalArgumentError {
1783 msg: "Invalid div between inf and -inf!!!".to_string(),
1784 }),
1785 ValueWrapper::NegInf => Err(IllegalArgumentError {
1786 msg: "Invalid div between -inf and -inf!!!".to_string(),
1787 }),
1788 }
1789 } else {
1790 match self {
1791 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value / rhs)),
1792 ValueWrapper::Inf => {
1793 if &rhs >= $type::ZERO {
1794 Ok(ValueWrapper::Inf)
1795 } else {
1796 Ok(ValueWrapper::NegInf)
1797 }
1798 }
1799 ValueWrapper::NegInf => {
1800 if &rhs >= $type::ZERO {
1801 Ok(ValueWrapper::NegInf)
1802 } else {
1803 Ok(ValueWrapper::Inf)
1804 }
1805 }
1806 }
1807 }
1808 }
1809 }
1810
1811 impl<'a, 'b> Div<&'b $type> for &'a ValueWrapper<$type> {
1812 type Output = Result<ValueWrapper<<&'a $type as Div<&'b $type>>::Output>, IllegalArgumentError>;
1813
1814 fn div(self, rhs: &'b $type) -> Self::Output {
1815 if rhs.is_nan() {
1816 Err(IllegalArgumentError {
1817 msg: "Illegal argument NaN for value range!!!".to_string(),
1818 })
1819 } else if rhs.is_inf() {
1820 match self {
1821 ValueWrapper::Value(_) => {
1822 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1823 }
1824 ValueWrapper::Inf => Err(IllegalArgumentError {
1825 msg: "Invalid div between inf and inf!!!".to_string(),
1826 }),
1827 ValueWrapper::NegInf => Err(IllegalArgumentError {
1828 msg: "Invalid div between -inf and inf!!!".to_string(),
1829 }),
1830 }
1831 } else if rhs.is_neg_inf() {
1832 match self {
1833 ValueWrapper::Value(_) => {
1834 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1835 }
1836 ValueWrapper::Inf => Err(IllegalArgumentError {
1837 msg: "Invalid div between inf and -inf!!!".to_string(),
1838 }),
1839 ValueWrapper::NegInf => Err(IllegalArgumentError {
1840 msg: "Invalid div between -inf and -inf!!!".to_string(),
1841 }),
1842 }
1843 } else {
1844 match self {
1845 ValueWrapper::Value(lhs_value) => Ok(ValueWrapper::from(lhs_value / rhs)),
1846 ValueWrapper::Inf => {
1847 if rhs >= $type::ZERO {
1848 Ok(ValueWrapper::Inf)
1849 } else {
1850 Ok(ValueWrapper::NegInf)
1851 }
1852 }
1853 ValueWrapper::NegInf => {
1854 if rhs >= $type::ZERO {
1855 Ok(ValueWrapper::NegInf)
1856 } else {
1857 Ok(ValueWrapper::Inf)
1858 }
1859 }
1860 }
1861 }
1862 }
1863 }
1864
1865 impl Div<ValueWrapper<$type>> for $type {
1866 type Output = Result<ValueWrapper<<$type as Div<$type>>::Output>, IllegalArgumentError>;
1867
1868 fn div(self, rhs: ValueWrapper<$type>) -> Self::Output {
1869 if self.is_nan() {
1870 Err(IllegalArgumentError {
1871 msg: "Illegal argument NaN for value range!!!".to_string(),
1872 })
1873 } else if self.is_inf() {
1874 match rhs {
1875 ValueWrapper::Value(_) => {
1876 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1877 }
1878 ValueWrapper::Inf => Err(IllegalArgumentError {
1879 msg: "Invalid div between inf and inf!!!".to_string(),
1880 }),
1881 ValueWrapper::NegInf => Err(IllegalArgumentError {
1882 msg: "Invalid div between -inf and inf!!!".to_string(),
1883 }),
1884 }
1885 } else if self.is_neg_inf() {
1886 match rhs {
1887 ValueWrapper::Value(_) => {
1888 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1889 }
1890 ValueWrapper::Inf => Err(IllegalArgumentError {
1891 msg: "Invalid div between inf and -inf!!!".to_string(),
1892 }),
1893 ValueWrapper::NegInf => Err(IllegalArgumentError {
1894 msg: "Invalid div between -inf and -inf!!!".to_string(),
1895 }),
1896 }
1897 } else {
1898 match rhs {
1899 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self / rhs_value)),
1900 ValueWrapper::Inf => {
1901 if &self >= $type::ZERO {
1902 Ok(ValueWrapper::Inf)
1903 } else {
1904 Ok(ValueWrapper::NegInf)
1905 }
1906 }
1907 ValueWrapper::NegInf => {
1908 if &self >= $type::ZERO {
1909 Ok(ValueWrapper::NegInf)
1910 } else {
1911 Ok(ValueWrapper::Inf)
1912 }
1913 }
1914 }
1915 }
1916 }
1917 }
1918
1919 impl<'a> Div<ValueWrapper<$type>> for &'a $type {
1920 type Output = Result<ValueWrapper<<$type as Div<$type>>::Output>, IllegalArgumentError>;
1921
1922 fn div(self, rhs: ValueWrapper<$type>) -> Self::Output {
1923 if self.is_nan() {
1924 Err(IllegalArgumentError {
1925 msg: "Illegal argument NaN for value range!!!".to_string(),
1926 })
1927 } else if self.is_inf() {
1928 match rhs {
1929 ValueWrapper::Value(_) => {
1930 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1931 }
1932 ValueWrapper::Inf => Err(IllegalArgumentError {
1933 msg: "Invalid div between inf and inf!!!".to_string(),
1934 }),
1935 ValueWrapper::NegInf => Err(IllegalArgumentError {
1936 msg: "Invalid div between -inf and inf!!!".to_string(),
1937 }),
1938 }
1939 } else if self.is_neg_inf() {
1940 match rhs {
1941 ValueWrapper::Value(_) => {
1942 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1943 }
1944 ValueWrapper::Inf => Err(IllegalArgumentError {
1945 msg: "Invalid div between inf and -inf!!!".to_string(),
1946 }),
1947 ValueWrapper::NegInf => Err(IllegalArgumentError {
1948 msg: "Invalid div between -inf and -inf!!!".to_string(),
1949 }),
1950 }
1951 } else {
1952 match rhs {
1953 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self / rhs_value)),
1954 ValueWrapper::Inf => {
1955 if self >= $type::ZERO {
1956 Ok(ValueWrapper::Inf)
1957 } else {
1958 Ok(ValueWrapper::NegInf)
1959 }
1960 }
1961 ValueWrapper::NegInf => {
1962 if self >= $type::ZERO {
1963 Ok(ValueWrapper::NegInf)
1964 } else {
1965 Ok(ValueWrapper::Inf)
1966 }
1967 }
1968 }
1969 }
1970 }
1971 }
1972
1973 impl<'a> Div<&'a ValueWrapper<$type>> for $type {
1974 type Output = Result<ValueWrapper<<$type as Div<&'a $type>>::Output>, IllegalArgumentError>;
1975
1976 fn div(self, rhs: &'a ValueWrapper<$type>) -> Self::Output {
1977 if self.is_nan() {
1978 Err(IllegalArgumentError {
1979 msg: "Illegal argument NaN for value range!!!".to_string(),
1980 })
1981 } else if self.is_inf() {
1982 match rhs {
1983 ValueWrapper::Value(_) => {
1984 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1985 }
1986 ValueWrapper::Inf => Err(IllegalArgumentError {
1987 msg: "Invalid div between inf and inf!!!".to_string(),
1988 }),
1989 ValueWrapper::NegInf => Err(IllegalArgumentError {
1990 msg: "Invalid div between -inf and inf!!!".to_string(),
1991 }),
1992 }
1993 } else if self.is_neg_inf() {
1994 match rhs {
1995 ValueWrapper::Value(_) => {
1996 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
1997 }
1998 ValueWrapper::Inf => Err(IllegalArgumentError {
1999 msg: "Invalid div between inf and -inf!!!".to_string(),
2000 }),
2001 ValueWrapper::NegInf => Err(IllegalArgumentError {
2002 msg: "Invalid div between -inf and -inf!!!".to_string(),
2003 }),
2004 }
2005 } else {
2006 match rhs {
2007 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self / rhs_value)),
2008 ValueWrapper::Inf => {
2009 if &self >= $type::ZERO {
2010 Ok(ValueWrapper::Inf)
2011 } else {
2012 Ok(ValueWrapper::NegInf)
2013 }
2014 }
2015 ValueWrapper::NegInf => {
2016 if &self >= $type::ZERO {
2017 Ok(ValueWrapper::NegInf)
2018 } else {
2019 Ok(ValueWrapper::Inf)
2020 }
2021 }
2022 }
2023 }
2024 }
2025 }
2026
2027 impl<'a, 'b> Div<&'b ValueWrapper<$type>> for &'a $type {
2028 type Output = Result<ValueWrapper<<$type as Div<&'b $type>>::Output>, IllegalArgumentError>;
2029
2030 fn div(self, rhs: &'b ValueWrapper<$type>) -> Self::Output {
2031 if self.is_nan() {
2032 Err(IllegalArgumentError {
2033 msg: "Illegal argument NaN for value range!!!".to_string(),
2034 })
2035 } else if self.is_inf() {
2036 match rhs {
2037 ValueWrapper::Value(_) => {
2038 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
2039 }
2040 ValueWrapper::Inf => Err(IllegalArgumentError {
2041 msg: "Invalid div between inf and inf!!!".to_string(),
2042 }),
2043 ValueWrapper::NegInf => Err(IllegalArgumentError {
2044 msg: "Invalid div between -inf and inf!!!".to_string(),
2045 }),
2046 }
2047 } else if self.is_neg_inf() {
2048 match rhs {
2049 ValueWrapper::Value(_) => {
2050 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
2051 }
2052 ValueWrapper::Inf => Err(IllegalArgumentError {
2053 msg: "Invalid div between inf and -inf!!!".to_string(),
2054 }),
2055 ValueWrapper::NegInf => Err(IllegalArgumentError {
2056 msg: "Invalid div between -inf and -inf!!!".to_string(),
2057 }),
2058 }
2059 } else {
2060 match rhs {
2061 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(self / rhs_value)),
2062 ValueWrapper::Inf => {
2063 if self >= $type::ZERO {
2064 Ok(ValueWrapper::Inf)
2065 } else {
2066 Ok(ValueWrapper::NegInf)
2067 }
2068 }
2069 ValueWrapper::NegInf => {
2070 if self >= $type::ZERO {
2071 Ok(ValueWrapper::NegInf)
2072 } else {
2073 Ok(ValueWrapper::Inf)
2074 }
2075 }
2076 }
2077 }
2078 }
2079 }
2080
2081 impl Div<ValueWrapper<$type>> for ValueWrapper<$type> {
2082 type Output = Result<ValueWrapper<<$type as Div<$type>>::Output>, IllegalArgumentError>;
2083
2084 fn div(self, rhs: ValueWrapper<$type>) -> Self::Output {
2085 match self {
2086 ValueWrapper::Value(lhs_value) => match rhs {
2087 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value / rhs_value)),
2088 ValueWrapper::Inf | ValueWrapper::NegInf => {
2089 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
2090 }
2091 },
2092 ValueWrapper::Inf => match rhs {
2093 ValueWrapper::Value(rhs_value) => {
2094 if &rhs_value >= $type::ZERO {
2095 Ok(ValueWrapper::Inf)
2096 } else {
2097 Ok(ValueWrapper::NegInf)
2098 }
2099 }
2100 ValueWrapper::Inf => Err(IllegalArgumentError {
2101 msg: "Invalid div between inf and inf!!!".to_string(),
2102 }),
2103 ValueWrapper::NegInf => Err(IllegalArgumentError {
2104 msg: "Invalid div between inf and -inf!!!".to_string(),
2105 }),
2106 },
2107 ValueWrapper::NegInf => match rhs {
2108 ValueWrapper::Value(rhs_value) => {
2109 if &rhs_value >= $type::ZERO {
2110 Ok(ValueWrapper::NegInf)
2111 } else {
2112 Ok(ValueWrapper::Inf)
2113 }
2114 }
2115 ValueWrapper::Inf => Err(IllegalArgumentError {
2116 msg: "Invalid div between -inf and inf!!!".to_string(),
2117 }),
2118 ValueWrapper::NegInf => Err(IllegalArgumentError {
2119 msg: "Invalid div between -inf and -inf!!!".to_string(),
2120 }),
2121 },
2122 }
2123 }
2124 }
2125
2126 impl<'a> Div<ValueWrapper<$type>> for &'a ValueWrapper<$type> {
2127 type Output = Result<ValueWrapper<<&'a $type as Div<$type>>::Output>, IllegalArgumentError>;
2128
2129 fn div(self, rhs: ValueWrapper<$type>) -> Self::Output {
2130 match self {
2131 ValueWrapper::Value(lhs_value) => match rhs {
2132 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value / rhs_value)),
2133 ValueWrapper::Inf | ValueWrapper::NegInf => {
2134 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
2135 }
2136 },
2137 ValueWrapper::Inf => match rhs {
2138 ValueWrapper::Value(rhs_value) => {
2139 if &rhs_value >= $type::ZERO {
2140 Ok(ValueWrapper::Inf)
2141 } else {
2142 Ok(ValueWrapper::NegInf)
2143 }
2144 }
2145 ValueWrapper::Inf => Err(IllegalArgumentError {
2146 msg: "Invalid div between inf and inf!!!".to_string(),
2147 }),
2148 ValueWrapper::NegInf => Err(IllegalArgumentError {
2149 msg: "Invalid div between inf and -inf!!!".to_string(),
2150 }),
2151 },
2152 ValueWrapper::NegInf => match rhs {
2153 ValueWrapper::Value(rhs_value) => {
2154 if &rhs_value >= $type::ZERO {
2155 Ok(ValueWrapper::NegInf)
2156 } else {
2157 Ok(ValueWrapper::Inf)
2158 }
2159 }
2160 ValueWrapper::Inf => Err(IllegalArgumentError {
2161 msg: "Invalid div between -inf and inf!!!".to_string(),
2162 }),
2163 ValueWrapper::NegInf => Err(IllegalArgumentError {
2164 msg: "Invalid div between -inf and -inf!!!".to_string(),
2165 }),
2166 },
2167 }
2168 }
2169 }
2170
2171 impl<'a> Div<&'a ValueWrapper<$type>> for ValueWrapper<$type> {
2172 type Output = Result<ValueWrapper<<$type as Div<&'a $type>>::Output>, IllegalArgumentError>;
2173
2174 fn div(self, rhs: &'a ValueWrapper<$type>) -> Self::Output {
2175 match self {
2176 ValueWrapper::Value(lhs_value) => match rhs {
2177 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value / rhs_value)),
2178 ValueWrapper::Inf | ValueWrapper::NegInf => {
2179 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
2180 }
2181 },
2182 ValueWrapper::Inf => match rhs {
2183 ValueWrapper::Value(rhs_value) => {
2184 if rhs_value >= $type::ZERO {
2185 Ok(ValueWrapper::Inf)
2186 } else {
2187 Ok(ValueWrapper::NegInf)
2188 }
2189 }
2190 ValueWrapper::Inf => Err(IllegalArgumentError {
2191 msg: "Invalid div between inf and inf!!!".to_string(),
2192 }),
2193 ValueWrapper::NegInf => Err(IllegalArgumentError {
2194 msg: "Invalid div between inf and -inf!!!".to_string(),
2195 }),
2196 },
2197 ValueWrapper::NegInf => match rhs {
2198 ValueWrapper::Value(rhs_value) => {
2199 if rhs_value >= $type::ZERO {
2200 Ok(ValueWrapper::NegInf)
2201 } else {
2202 Ok(ValueWrapper::Inf)
2203 }
2204 }
2205 ValueWrapper::Inf => Err(IllegalArgumentError {
2206 msg: "Invalid div between -inf and inf!!!".to_string(),
2207 }),
2208 ValueWrapper::NegInf => Err(IllegalArgumentError {
2209 msg: "Invalid div between -inf and -inf!!!".to_string(),
2210 }),
2211 },
2212 }
2213 }
2214 }
2215
2216 impl<'a, 'b> Div<&'b ValueWrapper<$type>> for &'a ValueWrapper<$type> {
2217 type Output = Result<ValueWrapper<<&'a $type as Div<&'b $type>>::Output>, IllegalArgumentError>;
2218
2219 fn div(self, rhs: &'b ValueWrapper<$type>) -> Self::Output {
2220 match self {
2221 ValueWrapper::Value(lhs_value) => match rhs {
2222 ValueWrapper::Value(rhs_value) => Ok(ValueWrapper::from(lhs_value / rhs_value)),
2223 ValueWrapper::Inf | ValueWrapper::NegInf => {
2224 Ok(ValueWrapper::from(<$type as Div<$type>>::Output::ZERO.clone()))
2225 }
2226 },
2227 ValueWrapper::Inf => match rhs {
2228 ValueWrapper::Value(rhs_value) => {
2229 if rhs_value >= $type::ZERO {
2230 Ok(ValueWrapper::Inf)
2231 } else {
2232 Ok(ValueWrapper::NegInf)
2233 }
2234 }
2235 ValueWrapper::Inf => Err(IllegalArgumentError {
2236 msg: "Invalid div between inf and inf!!!".to_string(),
2237 }),
2238 ValueWrapper::NegInf => Err(IllegalArgumentError {
2239 msg: "Invalid div between inf and -inf!!!".to_string(),
2240 }),
2241 },
2242 ValueWrapper::NegInf => match rhs {
2243 ValueWrapper::Value(rhs_value) => {
2244 if rhs_value >= $type::ZERO {
2245 Ok(ValueWrapper::NegInf)
2246 } else {
2247 Ok(ValueWrapper::Inf)
2248 }
2249 }
2250 ValueWrapper::Inf => Err(IllegalArgumentError {
2251 msg: "Invalid div between -inf and inf!!!".to_string(),
2252 }),
2253 ValueWrapper::NegInf => Err(IllegalArgumentError {
2254 msg: "Invalid div between -inf and -inf!!!".to_string(),
2255 }),
2256 },
2257 }
2258 }
2259 }
2260 )*)
2261}
2262real_number_value_wrapper_template! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize f32 f64 }