num-valid 0.3.3

A robust numerical library providing validated types for real and complex numbers to prevent common floating-point errors like NaN propagation. Features a generic, layered architecture with support for native f64 and optional arbitrary-precision arithmetic.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

#![deny(rustdoc::broken_intra_doc_links)]

//! In-place negation operations.
//!
//! This module provides the [`NegAssign`] trait for negating a value in place,
//! which is more efficient than creating a new negated value for heap-allocated types.

use duplicate::duplicate_item;
use num::Complex;

//-------------------------------------------------------------
/// Compound negation and assignment.
pub trait NegAssign {
    /// Performs the negation.
    fn neg_assign(&mut self);
}

#[duplicate_item(
    T;
    [f64];
    [Complex<f64>];
)]
/// Compound negation and assignment.
impl NegAssign for T {
    /// Performs the negation of `self`.
    fn neg_assign(&mut self) {
        *self = -*self;
    }
}

//-------------------------------------------------------------

//-------------------------------------------------------------
#[cfg(test)]
mod tests {
    use super::*;
    use num::Complex;

    mod native64 {
        use super::*;

        #[test]
        fn test_neg_assign_f64() {
            let mut value = 1.0_f64;
            value.neg_assign();
            let expected_value = -1.0_f64;
            assert_eq!(value, expected_value);

            let mut value = -2.0_f64;
            value.neg_assign();
            let expected_value = 2.0_f64;
            assert_eq!(value, expected_value);
        }

        #[test]
        fn test_neg_assign_complex_f64() {
            let mut value = Complex::new(1.0, -2.0);
            value.neg_assign();
            let expected_value = Complex::new(-1.0, 2.0);
            assert_eq!(value, expected_value);

            let mut value = Complex::new(-3.0, 4.0);
            value.neg_assign();
            let expected_value = Complex::new(3.0, -4.0);
            assert_eq!(value, expected_value);
        }
    }

    #[cfg(feature = "rug")]
    mod rug53 {
        use super::*;
        use crate::backends::rug::validated::{ComplexRugStrictFinite, RealRugStrictFinite};
        use rug::Float;
        use try_create::TryNew;

        const PRECISION: u32 = 53;

        #[test]
        fn test_neg_assign_real_rug() {
            let mut value =
                RealRugStrictFinite::<PRECISION>::try_new(Float::with_val(PRECISION, 1.0)).unwrap();
            value.neg_assign();
            let expected_value =
                RealRugStrictFinite::<PRECISION>::try_new(Float::with_val(PRECISION, -1.0))
                    .unwrap();
            assert_eq!(value, expected_value);

            let mut value =
                RealRugStrictFinite::<PRECISION>::try_new(Float::with_val(PRECISION, -2.0))
                    .unwrap();
            value.neg_assign();
            let expected_value =
                RealRugStrictFinite::<PRECISION>::try_new(Float::with_val(PRECISION, 2.0)).unwrap();
            assert_eq!(value, expected_value);
        }

        #[test]
        fn test_neg_assign_complex_rug() {
            let mut value = ComplexRugStrictFinite::<PRECISION>::try_new(rug::Complex::with_val(
                PRECISION,
                (
                    Float::with_val(PRECISION, 1.0),
                    Float::with_val(PRECISION, -2.0),
                ),
            ))
            .unwrap();
            value.neg_assign();
            let expected_value =
                ComplexRugStrictFinite::<PRECISION>::try_new(rug::Complex::with_val(
                    PRECISION,
                    (
                        Float::with_val(PRECISION, -1.0),
                        Float::with_val(PRECISION, 2.0),
                    ),
                ))
                .unwrap();
            assert_eq!(value, expected_value);

            let mut value = ComplexRugStrictFinite::<PRECISION>::try_new(rug::Complex::with_val(
                PRECISION,
                (
                    Float::with_val(PRECISION, -3.0),
                    Float::with_val(PRECISION, 4.0),
                ),
            ))
            .unwrap();
            value.neg_assign();
            let expected_value =
                ComplexRugStrictFinite::<PRECISION>::try_new(rug::Complex::with_val(
                    PRECISION,
                    (
                        Float::with_val(PRECISION, 3.0),
                        Float::with_val(PRECISION, -4.0),
                    ),
                ))
                .unwrap();
            assert_eq!(value, expected_value);
        }
    }
}
//-------------------------------------------------------------