normal_map 0.2.1

A struct that maps a range of values to the normalized range [0.0, 1.0]
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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

use crate::*;

#[test]
fn linear_map_f32() {
    let normal_map = f32::NormalMap::linear(-50.0, 50.0, f32::Unit::Generic);

    assert_approximate_f32(0.0, normal_map.normalize(-50.0));
    assert_approximate_f32(0.0, normal_map.normalize(-52.0));
    assert_approximate_f32(1.0, normal_map.normalize(50.0));
    assert_approximate_f32(1.0, normal_map.normalize(52.0));

    assert_approximate_f32(-50.0, normal_map.denormalize(0.0));
    assert_approximate_f32(50.0, normal_map.denormalize(1.0));

    assert_approximate_f32(0.5, normal_map.normalize(0.0));
    assert_approximate_f32(0.25, normal_map.normalize(-25.0));
    assert_approximate_f32(0.75, normal_map.normalize(25.0));

    assert_approximate_f32(0.0, normal_map.denormalize(0.5));
    assert_approximate_f32(-25.0, normal_map.denormalize(0.25));
    assert_approximate_f32(25.0, normal_map.denormalize(0.75));
}

#[test]
fn linear_map_f64() {
    let normal_map = f64::NormalMap::linear(-50.0, 50.0, f64::Unit::Generic);

    assert_approximate_f64(0.0, normal_map.normalize(-50.0));
    assert_approximate_f64(0.0, normal_map.normalize(-52.0));
    assert_approximate_f64(1.0, normal_map.normalize(50.0));
    assert_approximate_f64(1.0, normal_map.normalize(52.0));

    assert_approximate_f64(-50.0, normal_map.denormalize(0.0));
    assert_approximate_f64(50.0, normal_map.denormalize(1.0));

    assert_approximate_f64(0.5, normal_map.normalize(0.0));
    assert_approximate_f64(0.25, normal_map.normalize(-25.0));
    assert_approximate_f64(0.75, normal_map.normalize(25.0));

    assert_approximate_f64(0.0, normal_map.denormalize(0.5));
    assert_approximate_f64(-25.0, normal_map.denormalize(0.25));
    assert_approximate_f64(25.0, normal_map.denormalize(0.75));
}

#[test]
fn power_map_f32() {
    let normal_map = f32::NormalMap::power(-50.0, 50.0, 0.5, f32::Unit::Generic);

    assert_approximate_f32(0.0, normal_map.normalize(-50.0));
    assert_approximate_f32(0.0, normal_map.normalize(-52.0));
    assert_approximate_f32(1.0, normal_map.normalize(50.0));
    assert_approximate_f32(1.0, normal_map.normalize(52.0));

    assert_approximate_f32(-50.0, normal_map.denormalize(0.0));
    assert_approximate_f32(50.0, normal_map.denormalize(1.0));

    assert_approximate_f32(0.25, normal_map.normalize(0.0));
    assert_approximate_f32(0.0625, normal_map.normalize(-25.0));
    assert_approximate_f32(0.5625, normal_map.normalize(25.0));

    assert_approximate_f32(0.0, normal_map.denormalize(0.25));
    assert_approximate_f32(-25.0, normal_map.denormalize(0.0625));
    assert_approximate_f32(25.0, normal_map.denormalize(0.5625));
}

#[test]
fn power_map_f64() {
    let normal_map = f64::NormalMap::power(-50.0, 50.0, 0.5, f64::Unit::Generic);

    assert_approximate_f64(0.0, normal_map.normalize(-50.0));
    assert_approximate_f64(0.0, normal_map.normalize(-52.0));
    assert_approximate_f64(1.0, normal_map.normalize(50.0));
    assert_approximate_f64(1.0, normal_map.normalize(52.0));

    assert_approximate_f64(-50.0, normal_map.denormalize(0.0));
    assert_approximate_f64(50.0, normal_map.denormalize(1.0));

    assert_approximate_f64(0.25, normal_map.normalize(0.0));
    assert_approximate_f64(0.0625, normal_map.normalize(-25.0));
    assert_approximate_f64(0.5625, normal_map.normalize(25.0));

    assert_approximate_f64(0.0, normal_map.denormalize(0.25));
    assert_approximate_f64(-25.0, normal_map.denormalize(0.0625));
    assert_approximate_f64(25.0, normal_map.denormalize(0.5625));
}

#[test]
fn log_map_f32() {
    let normal_map = f32::NormalMap::log2(20.0, 20480.0);

    assert_approximate_f32(0.0, normal_map.normalize(20.0));
    assert_approximate_f32(0.0, normal_map.normalize(18.0));
    assert_approximate_f32(1.0, normal_map.normalize(20480.0));
    assert_approximate_f32(1.0, normal_map.normalize(20500.0));

    assert_approximate_f32(20.0, normal_map.denormalize(0.0));
    assert_approximate_f32(20480.0, normal_map.denormalize(1.0));

    assert_approximate_f32(0.1, normal_map.normalize(40.0));
    assert_approximate_f32(0.5643856, normal_map.normalize(1000.0));
    assert_approximate_f32(0.89657843, normal_map.normalize(10000.0));

    assert_approximate_f32(40.0, normal_map.denormalize(0.1));
    assert_approximate_f32(640.0, normal_map.denormalize(0.5));
    assert_approximate_f32(3620.3865, normal_map.denormalize(0.75));
}

#[test]
fn log_map_f64() {
    let normal_map = f64::NormalMap::log2(20.0, 20480.0);

    assert_approximate_f64(0.0, normal_map.normalize(20.0));
    assert_approximate_f64(0.0, normal_map.normalize(18.0));
    assert_approximate_f64(1.0, normal_map.normalize(20480.0));
    assert_approximate_f64(1.0, normal_map.normalize(20500.0));

    assert_approximate_f64(20.0, normal_map.denormalize(0.0));
    assert_approximate_f64(20480.0, normal_map.denormalize(1.0));

    assert_approximate_f64(0.1, normal_map.normalize(40.0));
    assert_approximate_f64(0.5643856189774724, normal_map.normalize(1000.0));
    assert_approximate_f64(0.8965784284662086, normal_map.normalize(10000.0));

    assert_approximate_f64(40.0, normal_map.denormalize(0.1));
    assert_approximate_f64(640.0, normal_map.denormalize(0.5));
    assert_approximate_f64(3620.3867196751216, normal_map.denormalize(0.75));
}

#[test]
fn discrete_map_f32() {
    let normal_map = f32::NormalMap::discrete::<isize>(-5, 5);

    assert_approximate_f32(0.0, normal_map.normalize(-5.0));
    assert_approximate_f32(0.0, normal_map.normalize(-6.0));
    assert_approximate_f32(1.0, normal_map.normalize(5.0));
    assert_approximate_f32(1.0, normal_map.normalize(6.0));

    assert_approximate_f32(-5.0, normal_map.denormalize(0.0));
    assert_approximate_f32(5.0, normal_map.denormalize(1.0));

    assert_approximate_f32(0.0, normal_map.normalize(-4.9));
    assert_approximate_f32(1.0, normal_map.normalize(4.9));
    assert_approximate_f32(0.2, normal_map.normalize(-3.0));
    assert_approximate_f32(0.8, normal_map.normalize(3.0));

    assert_approximate_f32(-3.0, normal_map.denormalize(0.2));
    assert_approximate_f32(3.0, normal_map.denormalize(0.8));
}

#[test]
fn discrete_map_f64() {
    let normal_map = f64::NormalMap::discrete::<isize>(-5, 5);

    assert_approximate_f64(0.0, normal_map.normalize(-5.0));
    assert_approximate_f64(0.0, normal_map.normalize(-6.0));
    assert_approximate_f64(1.0, normal_map.normalize(5.0));
    assert_approximate_f64(1.0, normal_map.normalize(6.0));

    assert_approximate_f64(-5.0, normal_map.denormalize(0.0));
    assert_approximate_f64(5.0, normal_map.denormalize(1.0));

    assert_approximate_f64(0.0, normal_map.normalize(-4.9));
    assert_approximate_f64(1.0, normal_map.normalize(4.9));
    assert_approximate_f64(0.2, normal_map.normalize(-3.0));
    assert_approximate_f64(0.8, normal_map.normalize(3.0));

    assert_approximate_f64(-3.0, normal_map.denormalize(0.2));
    assert_approximate_f64(3.0, normal_map.denormalize(0.8));
}

fn assert_approximate_f32(a: f32, b: f32) {
    assert!(
        (a - b).abs() <= 0.0001,
        "Values are not approximate: a = {}, b = {}",
        a,
        b
    );
}

fn assert_approximate_f64(a: f64, b: f64) {
    assert!(
        (a - b).abs() < 0.000000000001,
        "Values are not approximate: a = {}, b = {}",
        a,
        b
    );
}