hyperreal 0.12.0

Exact rational and computable real arithmetic in Rust
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use hyperreal::{Problem, Rational, Real, RealSign, ZeroKnowledge};

fn q(numerator: i64, denominator: u64) -> Rational {
    Rational::fraction(numerator, denominator).unwrap()
}

fn r(numerator: i64, denominator: u64) -> Real {
    Real::new(q(numerator, denominator))
}

fn assert_stable_facts(value: &Real) {
    let facts = value.structural_facts();

    for _ in 0..8 {
        assert_eq!(value.structural_facts(), facts);
        assert_eq!(value.zero_status(), facts.zero);
        assert_eq!(value.definitely_zero(), facts.zero == ZeroKnowledge::Zero);
        if facts.exact_rational {
            assert!(value.exact_rational().is_some());
        }
        if facts.zero == ZeroKnowledge::Zero {
            assert_eq!(facts.sign, Some(RealSign::Zero));
            assert!(facts.magnitude.is_none());
        }
        if facts.zero == ZeroKnowledge::NonZero {
            assert_ne!(facts.sign, Some(RealSign::Zero));
        }
    }
}

fn assert_same_semantics(left: &Real, right: &Real) {
    assert_eq!(left, right);
    assert_eq!(left.structural_facts(), right.structural_facts());
    assert_eq!(left.zero_status(), right.zero_status());
    assert_eq!(left.refine_sign_until(-64), right.refine_sign_until(-64));
    assert_eq!(left.to_f64_approx(), right.to_f64_approx());
}

#[test]
fn scalar_fact_queries_are_stable_across_repeated_and_warmed_access() {
    let values = [
        Real::zero(),
        Real::one(),
        Real::new(Rational::new(-7)),
        r(1, 1 << 20),
        Real::pi(),
        Real::e(),
        Real::tau(),
        r(2, 1).sqrt().unwrap(),
        Real::pi() - Real::new(Rational::new(3)),
        ((Real::pi() * Real::e() * r(2, 1).sqrt().unwrap()) / Real::e()).unwrap(),
    ];

    for value in values {
        assert_stable_facts(&value);
        let _ = value.to_f64_approx();
        let _ = value.refine_sign_until(-128);
        assert_stable_facts(&value);
    }
}

#[test]
fn equivalent_structural_forms_keep_same_public_semantics() {
    let pi_over_two = Real::pi() / Real::new(Rational::new(2));
    let half_pi = r(1, 2) * Real::pi();
    assert_same_semantics(&pi_over_two.unwrap(), &half_pi);

    assert_same_semantics(&Real::pi().sin(), &Real::zero());
    assert_same_semantics(&Real::e().ln().unwrap(), &Real::one());
    assert_same_semantics(
        &Real::new(Rational::new(1024)).ln().unwrap(),
        &(Real::new(Rational::new(10)) * Real::new(Rational::new(2)).ln().unwrap()),
    );
    assert_same_semantics(
        &((Real::pi() * Real::e() * r(2, 1).sqrt().unwrap()) / Real::e()).unwrap(),
        &(Real::pi() * r(2, 1).sqrt().unwrap()),
    );
}

#[test]
fn domain_boundaries_do_not_poison_later_valid_queries() {
    assert_eq!(
        Real::new(Rational::new(-1)).sqrt(),
        Err(Problem::SqrtNegative)
    );
    assert_eq!(Real::zero().ln(), Err(Problem::NotANumber));
    assert_eq!(Real::new(Rational::new(-1)).ln(), Err(Problem::NotANumber));
    assert_eq!(Real::new(Rational::new(2)).asin(), Err(Problem::NotANumber));
    assert_eq!(Real::new(Rational::new(2)).acos(), Err(Problem::NotANumber));
    assert_eq!(Real::one().atanh(), Err(Problem::Infinity));
    assert_eq!(
        Real::new(Rational::new(-1)).acosh(),
        Err(Problem::NotANumber)
    );

    assert_stable_facts(&Real::zero().sqrt().unwrap());
    assert_stable_facts(&r(1, 1_000_000).sqrt().unwrap());
    assert_stable_facts(&Real::one().ln().unwrap());
    assert_stable_facts(&r(999_999, 1_000_000).atanh().unwrap());
    assert_stable_facts(&r(1_000_001, 1_000_000).acosh().unwrap());
}

#[test]
fn float_import_preserves_dyadic_exactness_and_zero_facts() {
    let cases = [
        0.0,
        -0.0,
        0.5,
        -0.25,
        f64::MIN_POSITIVE,
        f64::from_bits(1),
        1.0e-12,
        1.0e6,
        0.1,
        0.2,
        0.3,
    ];

    for value in cases {
        let imported = Real::try_from(value).unwrap();
        assert_stable_facts(&imported);
        assert!(imported.exact_rational().is_some());
        if value == 0.0 {
            assert_eq!(imported.zero_status(), ZeroKnowledge::Zero);
        } else {
            assert_eq!(imported.zero_status(), ZeroKnowledge::NonZero);
        }
    }
}

#[test]
fn refinement_order_is_cache_coherent_for_cancellation_adversaries() {
    let values = [
        Real::pi() - r(355, 113),
        r(2, 1).sqrt().unwrap() - r(99, 70),
        ((Real::pi() * Real::e()) / Real::e()).unwrap() - Real::pi(),
        (r(2, 1).sqrt().unwrap() + r(2, 1).sqrt().unwrap())
            - Real::new(Rational::new(2)) * r(2, 1).sqrt().unwrap(),
    ];

    for value in values {
        let cold = value.structural_facts();
        let signs = [
            value.refine_sign_until(-32),
            value.refine_sign_until(-256),
            value.refine_sign_until(-64),
            value.refine_sign_until(-128),
        ];
        let warmed = value.structural_facts();
        if cold.zero == ZeroKnowledge::Zero {
            assert_eq!(warmed.zero, ZeroKnowledge::Zero);
        }
        if let Some(sign) = cold.sign {
            assert_eq!(warmed.sign, Some(sign));
        }
        assert_eq!(signs[0], signs[2]);
        if signs[1].is_some() {
            assert_eq!(signs[1], signs[3]);
        }
    }
}