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
extern crate num_cpus;
extern crate primal_sieve;
#[macro_use]
mod macros;
pub mod filter;
pub mod collection;
mod concurrent_help;
#[cfg(test)]
mod tests {
use filter::{
prime_filter,
old_prime_filter,
prime_filter_section_sequentially,
};
extern crate time;
extern crate num_cpus;
use self::time::PreciseTime;
#[test]
fn test_prime_filter(){
let n = 12345;
let new_pf = prime_filter(n);
let old_pf = old_prime_filter(n);
for i in 0..n{
assert_eq!(new_pf[i], old_pf[i], "Failed on number {}", i)
}
}
use collection::{
primes,
primes_section,
primes_concurrently,
primes_section_sequentially,
};
#[test]
fn test_prime_collection(){
let some_primes = [ 2, 3, 5, 7, 11, 13,
17, 19, 23, 29, 31,
37, 41, 43, 47, 53,
59, 61, 67, 71, 73,
79, 83, 89, 97, 101,
103, 107, 109, 113, 127,
131, 137, 139, 149, 151,
157, 163, 167, 173, 179,
181, 191, 193, 197, 199];
let test_primes: Vec<usize> = primes(200);
for i in 0..test_primes.len(){
assert_eq!(test_primes[i], some_primes[i], "Mismatch")
};
}
#[test]
fn test_prime_sec_collection(){
let some_primes = [ 101,
103, 107, 109, 113, 127,
131, 137, 139, 149, 151,
157, 163, 167, 173, 179,
181, 191, 193, 197, 199];
let test_primes: Vec<usize> = primes_section(100, 200);
for i in 0..test_primes.len(){
assert_eq!(test_primes[i], some_primes[i], "Mismatch")
};
}
#[test]
fn can_take_any_section_filter(){
let some_primes = old_prime_filter(200);
for min in 0..200{
for max in (min+1)..200{
for (i, is_prime) in prime_filter_section_sequentially(min, max).into_iter().enumerate(){
assert_eq!(some_primes[min+i], is_prime, "bad case from {} to {}", min, max);
}
}
}
}
#[test]
fn can_take_any_section(){
let some_primes = old_prime_filter(200);
for min in 0..200{
for max in (min+1)..200{
for prime in primes_section_sequentially(min, max).into_iter(){
assert!(some_primes[prime], "bad case from {} to {}: prime: {}", min, max, prime);
}
}
}
}
#[test]
fn count_primes(){
let n = 100_000_000;
let start = PreciseTime::now();
let primes = primes(n);
let end = PreciseTime::now();
println!("{} seconds to find all primes less than {}!", start.to(end), n);
println!("{} primes total!", primes.len());
let total_primes = primes.len();
assert_eq!(total_primes, 5761455);
}
#[test]
fn count_primes_concurrently(){
let threads = num_cpus::get();
let n = 1_000_000_000;
let start = PreciseTime::now();
let primes = primes_concurrently(n, threads);
let end = PreciseTime::now();
println!("{} seconds to find all primes less than {}! (Threads: {})", start.to(end), n, threads);
println!("{} primes total!", primes.len());
let total_primes = primes.len();
assert_eq!(total_primes, 50_847_534);
}
#[test]
fn count_prime_section(){
let min = 1_000_000;
let max = 10_000_000;
let primes = primes_section(min, max);
let total_primes = primes.len();
assert_eq!(total_primes, 586081);
}
#[test]
fn count_primes_with_filter(){
let n = 100_000_000;
let start = PreciseTime::now();
let primes = prime_filter(n);
let end = PreciseTime::now();
println!("{} seconds to generate a prime filter less than {}!", start.to(end), n);
let total_primes = primes.iter().fold(0, |acc, &x| acc + (if x {1} else {0}));
assert_eq!(total_primes, 5761455);
}
#[test]
fn big_distant_section(){
let min = 10000000000000000;
let max = 10000000100000000;
let start = PreciseTime::now();
let primes = primes_section(min, max);
let end = PreciseTime::now();
println!("{} seconds to find big prime section!", start.to(end));
println!("First prime = {}, Last prime = {}", primes[0], primes.last().unwrap());
let total_primes = primes.len();
assert_eq!(total_primes, 2714904);
}
}