fixed_math 0.4.1

Some math traits and functions for `fixed` point numbers.
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

use fixed::types::*;
use fixed_math::Sqrt;

fn main() {
    let v = vec![
        I32F32::from_num(2),
        I32F32::PI,
        I32F32::MAX,
        I32F32::MAX >> 1u32,
    ];
    println!("I32F32");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I1F31::from_num(0.2), I1F31::MAX, I1F31::MAX >> 1u32];
    println!("I1F31");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![
        U32F32::from_num(2),
        U32F32::PI,
        U32F32::MAX,
        U32F32::MAX >> 1u32,
    ];
    println!("U32F32");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![
        U64F64::from_num(2),
        U64F64::PI,
        U64F64::MAX,
        U64F64::MAX >> 1u32,
    ];
    println!("U64F64");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I1F127::from_num(0.5), I1F127::MAX, I1F127::MAX >> 1u32];
    println!("I1F127");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![U1F127::from_num(0.5), U1F127::MAX, U1F127::MAX >> 1u32];
    println!("U1F127");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![U1F31::from_num(0.5), U1F31::MAX, U1F31::MAX >> 1u32];
    println!("U1F31");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![U0F32::from_num(0.5), U0F32::MAX, U0F32::MAX >> 1u32];
    println!("U0F32");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![U0F128::from_num(0.5), U0F128::MAX, U0F128::MAX >> 1u32];
    println!("U0F128");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![U3F29::from_num(0.5), U3F29::MAX, U3F29::MAX >> 1u32];
    println!("U3F29");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![U1F7::from_num(0.5), U1F7::MAX, U1F7::MAX >> 1u32];
    println!("U1F7");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I1F7::from_num(0.5), I1F7::MAX, I1F7::MAX >> 1u32];
    println!("I1F7");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![U3F5::from_num(0.5), U3F5::MAX, U3F5::MAX >> 1u32];
    println!("U3F5");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![U2F6::from_num(0.5), U2F6::MAX, U2F6::MAX >> 1u32];
    println!("U2F6");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I2F6::from_num(0.5), I2F6::MAX, I2F6::MAX >> 1u32];
    println!("I2F6");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I4F4::from_num(0.5), I4F4::MAX, I4F4::MAX >> 1u32];
    println!("I4F4");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I6F2::from_num(0.5), I6F2::MAX, I6F2::MAX >> 1u32];
    println!("I6F2");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I2F14::from_num(0.5), I2F14::MAX, I2F14::MAX >> 1u32];
    println!("I2F14");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I8F8::from_num(0.5), I8F8::MAX, I8F8::MAX >> 1u32];
    println!("I8F8");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![I14F2::from_num(0.5), I14F2::MAX, I14F2::MAX >> 1u32];
    println!("I14F2");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }

    let v = vec![
        I32F96::from_num(0.5),
        I32F96::from_num(2),
        I32F96::MAX,
        I32F96::MAX >> 1u32,
    ];
    println!("I32F96");
    for n in v {
        println!("sqrt {} = {}", n, n.sqrt());
    }
}