feat: NCC functional and buffered

src/main.rs

@@ -1,41 +1,63 @@
 use std::fs::File;
-use std::io::Read;
+use std::io::{BufReader, Read};
 
 fn main() {
-    for n in 1..=100 {
-        if isprime_trial(n) {
-            println!("{} is prime", n)
-        }
-    }
-
     let res = load_ncc_known_primes("/home/didas/Downloads/known_primes.res").unwrap();
 
-    println!("Got {:x}", res[0]);
+    println!("Loaded {}", res.len());
+
+    for n in 1..=10000000 {
+        if isprime_trial_res(n, &res) {
+            //println!("{} is prime", n);
+        }
+        if isprime_trial_res(n, &res) != isprime_trial(n, 3) {
+            println!("WRONG {}", n);
+        }
+    }
 }
 
 fn load_ncc_known_primes(path: &str) -> Option<Vec<u64>> {
-    let mut file = File::open(&path).ok()?;
+    let f = File::open(path).ok()?;
-    println!("Open");
+    let mut file = BufReader::new(f);
     let mut buf: [u8; 8] = [0u8; 8];
-    let read = file.read(&mut buf).ok()?;
+    if file.read(&mut buf).ok()? != 8 {
-    if read != 8 {
+        return None;
-        panic!();
     }
 
     if buf[0] != 1 || buf[1] != 2 || buf[2] != 0 || buf[3] != 2 {
         return None;
     }
 
-    let prime_count = u32::from_le_bytes(buf[4..8]);
+    let prime_count: usize = u32::from_le_bytes(buf[4..8].try_into().unwrap()) as usize;
-    println!("Found {} primes", prime_count);
+    println!("Found {} primes in res", prime_count);
 
     let mut vec = Vec::new();
-    vec.push(0);
+    vec.reserve_exact(prime_count);
+
+    let mut last: u64 = 0;
+    while vec.len() < (prime_count/16)-1 { //-1 because idfk
+        if last == 0 {
+            if file.read(&mut buf).ok()? != 8 {
+                println!("Full read {}", vec.len());
+                return None;
+            }
+            last = u64::from_le_bytes(buf);
+        } else {
+            if file.read(&mut buf[..2]).ok()? != 2 {
+                println!("Partial read {}", vec.len());
+                return None;
+            }
+            last += u16::from_le_bytes(buf[..2].try_into().unwrap()) as u64;
+        }
+        if last != 0 {
+            vec.push(last);
+        }
+    }
 
     return Some(vec);
 }
 
-fn isprime_trial(num: u64) -> bool {
+fn isprime_trial_res(num: u64, known_primes: &[u64]) -> bool {
     if num < 2 {
         return false;
     }
@@ -44,16 +66,47 @@ fn isprime_trial(num: u64) -> bool {
         return true;
     }
 
-    if (num % 2) == 0 {
+    if num.is_multiple_of(2) {
+        return false;
+    }
+
+    let sqrt = sqrt_u64(num);
+    let mut divider = 0;
+    let mut i: usize = 0;
+
+    while divider < sqrt && i < known_primes.len() {
+        divider = known_primes[i];
+        i += 1;
+
+        if num.is_multiple_of(divider) {
+            return false;
+        }
+    }
+
+    if divider < sqrt {
+        return isprime_trial(num, divider);
+    }
+
+    return true;
+}
+
+fn isprime_trial(num: u64, mut divider: u64) -> bool {
+    if num < 2 {
+        return false;
+    }
+
+    if num < 4 {
+        return true;
+    }
+
+    if num.is_multiple_of(2) {
         return false;
     }
 
     let sqrt = sqrt_u64(num);
 
-    let mut divider = 3;
-
     while divider <= sqrt {
-        if (num % divider) == 0 {
+        if num.is_multiple_of(divider) {
             return false;
         }