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
pub fn round(number: f64, rounding: i32) -> f64 {
match rounding {
1 => (number * 10.).round() / 10.,
2 => (number * 100.).round() / 100.,
3 => (number * 1000.).round() / 1000.,
4 => (number * 10000.).round() / 10000.,
5 => (number * 100000.).round() / 100000.,
6 => (number * 1000000.).round() / 1000000.,
7 => (number * 10000000.).round() / 10000000.,
8 => (number * 100000000.).round() / 100000000.,
9 => (number * 1000000000.).round() / 1000000000.,
10 => (number * 10000000000.).round() / 10000000000.,
_ => (number * 100.).round() / 100.,
}
}
#[test]
fn test_round_by2() {
let test_n = round(8.9534, 2);
assert_eq!(test_n, 8.95);
}
#[test]
fn test_round_by3() {
let test_n = round(8.9536, 3);
assert_eq!(test_n, 8.954);
}
#[test]
fn test_default_rounding() {
let test_n = round(8.9536, -1);
assert_eq!(test_n, 8.95);
}
pub fn round_up(number: f64, rounding: i32) -> f64 {
match rounding {
1 => (number * 10.).ceil() / 10.,
2 => (number * 100.).ceil() / 100.,
3 => (number * 1000.).ceil() / 1000.,
4 => (number * 10000.).ceil() / 10000.,
5 => (number * 100000.).ceil() / 100000.,
6 => (number * 1000000.).ceil() / 1000000.,
7 => (number * 10000000.).ceil() / 10000000.,
8 => (number * 100000000.).ceil() / 100000000.,
9 => (number * 1000000000.).ceil() / 1000000000.,
10 => (number * 10000000000.).ceil() / 10000000000.,
_ => (number * 100.).ceil() / 100.,
}
}
#[test]
fn test_round_up_by2() {
let test_n = round_up(8.9534, 2);
assert_eq!(test_n, 8.96);
}
#[test]
fn test_round_up_by3() {
let test_n = round_up(8.9536, 3);
assert_eq!(test_n, 8.954);
}
#[test]
fn test_default_round_up() {
let test_n = round_up(8.9536, -1);
assert_eq!(test_n, 8.96);
}
pub fn round_down(number: f64, rounding: i32) -> f64 {
match rounding {
1 => (number * 10.).floor() / 10.,
2 => (number * 100.).floor() / 100.,
3 => (number * 1000.).floor() / 1000.,
4 => (number * 10000.).floor() / 10000.,
5 => (number * 100000.).floor() / 100000.,
6 => (number * 1000000.).floor() / 1000000.,
7 => (number * 10000000.).floor() / 10000000.,
8 => (number * 100000000.).floor() / 100000000.,
9 => (number * 1000000000.).floor() / 1000000000.,
10 => (number * 10000000000.).floor() / 10000000000.,
_ => (number * 100.).floor() / 100.,
}
}
#[test]
fn test_round_down_by2() {
let test_n = round_down(8.9534, 2);
assert_eq!(test_n, 8.95);
}
#[test]
fn test_round_down_by3() {
let test_n = round_down(8.9536, 3);
assert_eq!(test_n, 8.953);
}
#[test]
fn test_default_round_down() {
let test_n = round_down(8.9536, -1);
assert_eq!(test_n, 8.95);
}