Primes/Utility.cs at master · wheresthecode/Primes · GitHub

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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Diagnostics;
usingSystem.Text;
usingSystem.Threading;

namespacePrimes
{
classPrimeGeneratorUtility
{
publicstaticList<long>GetPrimesSimple(intn)
{
List<long>list=newList<long>();
list.Add(2);
longcheckNum=3;
while(checkNum<n)
{
boolisPrime=true;
foreach(longprimeinlist)
{
if((checkNum%prime)==0)
{
isPrime=false;
break;
}
}
if(isPrime)
{
list.Add(checkNum);
}
checkNum+=2;
}
returnlist;
}

publicstaticList<long>GetPrimesWindowed(intn,intwindowSize)
{
intwindowOffset=windowSize;
// TODO: Creating the first window is kind of an edge case so I'm using the simple generator for it.
// It'd be better to handle the edge case
List<long>primes=GetPrimesSimple(windowSize);
bool[]window=newbool[windowSize];
while(windowOffset<n)
{
Array.Clear(window,0,windowSize);
foreach(longprimeinprimes)
{
longstartIdx=(windowOffset/prime)*prime;
if(startIdx<windowOffset)
{
startIdx+=prime;
}
startIdx-=windowOffset;
Debug.Assert(startIdx>=0);
while(startIdx<windowSize)
{
window[startIdx]=true;
startIdx+=prime;
}
}

intcount=Math.Min(n-windowOffset,windowSize);
for(inti=0;i<count;i++)
{
if(!window[i])
{
primes.Add(windowOffset+i);
}
}
windowOffset+=windowSize;
}

returnprimes;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Diagnostics;
usingSystem.Text;
usingSystem.Threading;

namespacePrimes
{
classPrimeGeneratorUtility
{
publicstaticList<long>GetPrimesSimple(intn)
{
List<long>list=newList<long>();
list.Add(2);
longcheckNum=3;
while(checkNum<n)
{
boolisPrime=true;
foreach(longprimeinlist)
{
if((checkNum%prime)==0)
{
isPrime=false;
break;
}
}
if(isPrime)
{
list.Add(checkNum);
}
checkNum+=2;
}
returnlist;
}

publicstaticList<long>GetPrimesWindowed(intn,intwindowSize)
{
intwindowOffset=windowSize;
// TODO: Creating the first window is kind of an edge case so I'm using the simple generator for it.
// It'd be better to handle the edge case
List<long>primes=GetPrimesSimple(windowSize);
bool[]window=newbool[windowSize];
while(windowOffset<n)
{
Array.Clear(window,0,windowSize);
foreach(longprimeinprimes)
{
longstartIdx=(windowOffset/prime)*prime;
if(startIdx<windowOffset)
{
startIdx+=prime;
}
startIdx-=windowOffset;
Debug.Assert(startIdx>=0);
while(startIdx<windowSize)
{
window[startIdx]=true;
startIdx+=prime;
}
}

intcount=Math.Min(n-windowOffset,windowSize);
for(inti=0;i<count;i++)
{
if(!window[i])
{
primes.Add(windowOffset+i);
}
}
windowOffset+=windowSize;
}

returnprimes;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Diagnostics;
usingSystem.Text;
usingSystem.Threading;

namespacePrimes
{
classPrimeGeneratorUtility
{
publicstaticList<long>GetPrimesSimple(intn)
{
List<long>list=newList<long>();
list.Add(2);
longcheckNum=3;
while(checkNum<n)
{
boolisPrime=true;
foreach(longprimeinlist)
{
if((checkNum%prime)==0)
{
isPrime=false;
break;
}
}
if(isPrime)
{
list.Add(checkNum);
}
checkNum+=2;
}
returnlist;
}

publicstaticList<long>GetPrimesWindowed(intn,intwindowSize)
{
intwindowOffset=windowSize;
// TODO: Creating the first window is kind of an edge case so I'm using the simple generator for it.
// It'd be better to handle the edge case
List<long>primes=GetPrimesSimple(windowSize);
bool[]window=newbool[windowSize];
while(windowOffset<n)
{
Array.Clear(window,0,windowSize);
foreach(longprimeinprimes)
{
longstartIdx=(windowOffset/prime)*prime;
if(startIdx<windowOffset)
{
startIdx+=prime;
}
startIdx-=windowOffset;
Debug.Assert(startIdx>=0);
while(startIdx<windowSize)
{
window[startIdx]=true;
startIdx+=prime;
}
}

intcount=Math.Min(n-windowOffset,windowSize);
for(inti=0;i<count;i++)
{
if(!window[i])
{
primes.Add(windowOffset+i);
}
}
windowOffset+=windowSize;
}

returnprimes;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Diagnostics;
usingSystem.Text;
usingSystem.Threading;

namespacePrimes
{
classPrimeGeneratorUtility
{
publicstaticList<long>GetPrimesSimple(intn)
{
List<long>list=newList<long>();
list.Add(2);
longcheckNum=3;
while(checkNum<n)
{
boolisPrime=true;
foreach(longprimeinlist)
{
if((checkNum%prime)==0)
{
isPrime=false;
break;
}
}
if(isPrime)
{
list.Add(checkNum);
}
checkNum+=2;
}
returnlist;
}

publicstaticList<long>GetPrimesWindowed(intn,intwindowSize)
{
intwindowOffset=windowSize;
// TODO: Creating the first window is kind of an edge case so I'm using the simple generator for it.
// It'd be better to handle the edge case
List<long>primes=GetPrimesSimple(windowSize);
bool[]window=newbool[windowSize];
while(windowOffset<n)
{
Array.Clear(window,0,windowSize);
foreach(longprimeinprimes)
{
longstartIdx=(windowOffset/prime)*prime;
if(startIdx<windowOffset)
{
startIdx+=prime;
}
startIdx-=windowOffset;
Debug.Assert(startIdx>=0);
while(startIdx<windowSize)
{
window[startIdx]=true;
startIdx+=prime;
}
}

intcount=Math.Min(n-windowOffset,windowSize);
for(inti=0;i<count;i++)
{
if(!window[i])
{
primes.Add(windowOffset+i);
}
}
windowOffset+=windowSize;
}

returnprimes;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Diagnostics;
usingSystem.Text;
usingSystem.Threading;

namespacePrimes
{
classPrimeGeneratorUtility
{
publicstaticList<long>GetPrimesSimple(intn)
{
List<long>list=newList<long>();
list.Add(2);
longcheckNum=3;
while(checkNum<n)
{
boolisPrime=true;
foreach(longprimeinlist)
{
if((checkNum%prime)==0)
{
isPrime=false;
break;
}
}
if(isPrime)
{
list.Add(checkNum);
}
checkNum+=2;
}
returnlist;
}

publicstaticList<long>GetPrimesWindowed(intn,intwindowSize)
{
intwindowOffset=windowSize;
// TODO: Creating the first window is kind of an edge case so I'm using the simple generator for it.
// It'd be better to handle the edge case
List<long>primes=GetPrimesSimple(windowSize);
bool[]window=newbool[windowSize];
while(windowOffset<n)
{
Array.Clear(window,0,windowSize);
foreach(longprimeinprimes)
{
longstartIdx=(windowOffset/prime)*prime;
if(startIdx<windowOffset)
{
startIdx+=prime;
}
startIdx-=windowOffset;
Debug.Assert(startIdx>=0);
while(startIdx<windowSize)
{
window[startIdx]=true;
startIdx+=prime;
}
}

intcount=Math.Min(n-windowOffset,windowSize);
for(inti=0;i<count;i++)
{
if(!window[i])
{
primes.Add(windowOffset+i);
}
}
windowOffset+=windowSize;
}

returnprimes;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Diagnostics;
usingSystem.Text;
usingSystem.Threading;

namespacePrimes
{
classPrimeGeneratorUtility
{
publicstaticList<long>GetPrimesSimple(intn)
{
List<long>list=newList<long>();
list.Add(2);
longcheckNum=3;
while(checkNum<n)
{
boolisPrime=true;
foreach(longprimeinlist)
{
if((checkNum%prime)==0)
{
isPrime=false;
break;
}
}
if(isPrime)
{
list.Add(checkNum);
}
checkNum+=2;
}
returnlist;
}

publicstaticList<long>GetPrimesWindowed(intn,intwindowSize)
{
intwindowOffset=windowSize;
// TODO: Creating the first window is kind of an edge case so I'm using the simple generator for it.
// It'd be better to handle the edge case
List<long>primes=GetPrimesSimple(windowSize);
bool[]window=newbool[windowSize];
while(windowOffset<n)
{
Array.Clear(window,0,windowSize);
foreach(longprimeinprimes)
{
longstartIdx=(windowOffset/prime)*prime;
if(startIdx<windowOffset)
{
startIdx+=prime;
}
startIdx-=windowOffset;
Debug.Assert(startIdx>=0);
while(startIdx<windowSize)
{
window[startIdx]=true;
startIdx+=prime;
}
}

intcount=Math.Min(n-windowOffset,windowSize);
for(inti=0;i<count;i++)
{
if(!window[i])
{
primes.Add(windowOffset+i);
}
}
windowOffset+=windowSize;
}

returnprimes;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Diagnostics;
usingSystem.Text;
usingSystem.Threading;

namespacePrimes
{
classPrimeGeneratorUtility
{
publicstaticList<long>GetPrimesSimple(intn)
{
List<long>list=newList<long>();
list.Add(2);
longcheckNum=3;
while(checkNum<n)
{
boolisPrime=true;
foreach(longprimeinlist)
{
if((checkNum%prime)==0)
{
isPrime=false;
break;
}
}
if(isPrime)
{
list.Add(checkNum);
}
checkNum+=2;
}
returnlist;
}

publicstaticList<long>GetPrimesWindowed(intn,intwindowSize)
{
intwindowOffset=windowSize;
// TODO: Creating the first window is kind of an edge case so I'm using the simple generator for it.
// It'd be better to handle the edge case
List<long>primes=GetPrimesSimple(windowSize);
bool[]window=newbool[windowSize];
while(windowOffset<n)
{
Array.Clear(window,0,windowSize);
foreach(longprimeinprimes)
{
longstartIdx=(windowOffset/prime)*prime;
if(startIdx<windowOffset)
{
startIdx+=prime;
}
startIdx-=windowOffset;
Debug.Assert(startIdx>=0);
while(startIdx<windowSize)
{
window[startIdx]=true;
startIdx+=prime;
}
}

intcount=Math.Min(n-windowOffset,windowSize);
for(inti=0;i<count;i++)
{
if(!window[i])
{
primes.Add(windowOffset+i);
}
}
windowOffset+=windowSize;
}

returnprimes;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Diagnostics;
usingSystem.Text;
usingSystem.Threading;

namespacePrimes
{
classPrimeGeneratorUtility
{
publicstaticList<long>GetPrimesSimple(intn)
{
List<long>list=newList<long>();
list.Add(2);
longcheckNum=3;
while(checkNum<n)
{
boolisPrime=true;
foreach(longprimeinlist)
{
if((checkNum%prime)==0)
{
isPrime=false;
break;
}
}
if(isPrime)
{
list.Add(checkNum);
}
checkNum+=2;
}
returnlist;
}

publicstaticList<long>GetPrimesWindowed(intn,intwindowSize)
{
intwindowOffset=windowSize;
// TODO: Creating the first window is kind of an edge case so I'm using the simple generator for it.
// It'd be better to handle the edge case
List<long>primes=GetPrimesSimple(windowSize);
bool[]window=newbool[windowSize];
while(windowOffset<n)
{
Array.Clear(window,0,windowSize);
foreach(longprimeinprimes)
{
longstartIdx=(windowOffset/prime)*prime;
if(startIdx<windowOffset)
{
startIdx+=prime;
}
startIdx-=windowOffset;
Debug.Assert(startIdx>=0);
while(startIdx<windowSize)
{
window[startIdx]=true;
startIdx+=prime;
}
}

intcount=Math.Min(n-windowOffset,windowSize);
for(inti=0;i<count;i++)
{
if(!window[i])
{
primes.Add(windowOffset+i);
}
}
windowOffset+=windowSize;
}

returnprimes;
}
}
}