Add renovate.json

.gitignore

@@ -1,9 +1,3 @@
 /target
 report.json
-primes.json
+primes.json
-primes*.json
-primes*.txt
-primes*.zip
-dhat*
-flamegraph*
-perf*

Cargo.lock

@@ -4,15 +4,9 @@ version = 3
 
 [[package]]
 name = "autocfg"
-version = "1.3.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
-[[package]]
-name = "bitflags"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "cfg-if"
@@ -22,9 +16,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
  "cfg-if",
  "libc",
@@ -37,35 +31,30 @@ version = "0.1.0"
 dependencies = [
  "num",
  "num-bigint",
- "once_cell",
  "rand",
- "serde_json",
  "thread-priority",
 ]
 
-[[package]]
-name = "itoa"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
-
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.139"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
 
 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+dependencies = [
+ "cfg-if",
+]
 
 [[package]]
 name = "num"
-version = "0.4.3"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
+checksum = "43db66d1170d347f9a065114077f7dccb00c1b9478c89384490a3425279a4606"
 dependencies = [
  "num-bigint",
  "num-complex",
@@ -77,38 +66,39 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.6"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
 dependencies = [
+ "autocfg",
  "num-integer",
  "num-traits",
- "serde",
 ]
 
 [[package]]
 name = "num-complex"
-version = "0.4.6"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+checksum = "02e0d21255c828d6f128a1e41534206671e8c3ea0c62f32291e808dc82cff17d"
 dependencies = [
  "num-traits",
 ]
 
 [[package]]
 name = "num-integer"
-version = "0.1.46"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
 dependencies = [
+ "autocfg",
  "num-traits",
 ]
 
 [[package]]
 name = "num-iter"
-version = "0.1.45"
+version = "0.1.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
 dependencies = [
  "autocfg",
  "num-integer",
@@ -117,10 +107,11 @@ dependencies = [
 
 [[package]]
 name = "num-rational"
-version = "0.4.2"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
 dependencies = [
+ "autocfg",
  "num-bigint",
  "num-integer",
  "num-traits",
@@ -128,43 +119,19 @@ dependencies = [
 
 [[package]]
 name = "num-traits"
-version = "0.2.19"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "once_cell"
-version = "1.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
-[[package]]
-name = "proc-macro2"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.36"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
-dependencies = [
- "proc-macro2",
-]
-
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -197,65 +164,16 @@ dependencies = [
 
 [[package]]
 name = "rustversion"
-version = "1.0.17"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+checksum = "5583e89e108996506031660fe09baa5011b9dd0341b89029313006d1fb508d70"
-
-[[package]]
-name = "ryu"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
-
-[[package]]
-name = "serde"
-version = "1.0.204"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.204"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.120"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.71"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b146dcf730474b4bcd16c311627b31ede9ab149045db4d6088b3becaea046462"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
 
 [[package]]
 name = "thread-priority"
-version = "1.1.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d3b04d33c9633b8662b167b847c7ab521f83d1ae20f2321b65b5b925e532e36"
+checksum = "2ee4429f2c3bbeafa7136ea54d75a5f38b02e4f006c0b310f07e35c3b49eb3e7"
 dependencies = [
- "bitflags",
  "cfg-if",
  "libc",
  "log",
@@ -263,12 +181,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "unicode-ident"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
-
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"

Cargo.toml

@@ -2,48 +2,17 @@
 name = "isprime"
 version = "0.1.0"
 edition = "2021"
-default-run = "isprime"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-num = "0.4"
+num = "0.4.0"
-rand = "0.8"
+thread-priority = "0.12.0"
-num-bigint = { default-features = false, version = "0.4", features = ["serde"] }
+rand = "0.8.5"
-once_cell = "1.19"
+num-bigint= { default-features = false, version = "0.4.3" }
-serde_json = "1.0"
-
-[target.'cfg(windows)'.dependencies]
-thread-priority = "1.1"
 
 [profile.release]
-lto = true              # Enable link-time optimization
+lto = true          # Enable link-time optimization
-codegen-units = 1       # Reduce number of codegen units to increase optimizations
+codegen-units = 1   # Reduce number of codegen units to increase optimizations
-panic = 'abort'         # Abort on panic
+panic = 'abort'     # Abort on panic
-# strip = true            # Strip symbols from binary; remove pdb
+strip = true        # Strip symbols from binary; remove pdb
-overflow-checks = false
-debug = true
-
-[profile.dev]
-opt-level = 3
-
-[lints.clippy]
-pedantic = { level = "deny", priority = -1 }
-perf = { level = "deny", priority = 1 }
-complexity = { level = "deny", priority = -1 }
-style = { level = "deny", priority = -1 }
-correctness = { level = "deny", priority = -1 }
-format_collect = "deny"
-format_in_format_args = "deny"
-format_push_string = "deny"
-mut_mut = "deny"
-let_underscore_untyped = "deny"
-str_to_string = "deny"
-
-cast_possible_truncation = "allow"
-cast_precision_loss = "allow"
-cast_sign_loss = "allow"
-missing_errors_doc = "allow"
-
-[[bin]]
-name = "isprime"

check_primes.js

@@ -1,26 +0,0 @@
-const assert = require("assert");
-
-const primes_generated = require("./primes.json");
-const correct_primes = require("./primes1.json");
-
-assert(
-  primes_generated.length == correct_primes.length,
-  "Number of primes generated is not equal to the number of correct primes",
-);
-
-for (let i = 0; i < primes_generated.length; i++) {
-  if (primes_generated[i] !== correct_primes[i]) {
-    let bigger_smaller = "="
-    if (primes_generated[i] > correct_primes[i]) { bigger_smaller = ">" } else if (primes_generated[i] < correct_primes[i]) { "<" }
-    console.error(
-      `Incorrect prime at index ${i}: ${primes_generated[i]}(gen) | ${correct_primes[i]}(list) | gen is ${bigger_smaller}`,
-    );
-    process.exit(1);
-  }
-}
-
-console.log("All primes are correct");
-console.log(
-  "Last prime in generated primes: ",
-  primes_generated[primes_generated.length - 1],
-);

convert_primelist.py

@@ -1,28 +0,0 @@
-import json
-
-def convert_primes_to_json(file_path):
-    # Step 1: Read the file content
-    with open(file_path, 'r') as file:
-        lines = file.readlines()
-
-    primes = []
-    for line in lines:
-        # Step 2: Extract prime numbers
-        # Split each line into words and filter out non-numeric entries
-        numbers = [num for num in line.split() if num.isdigit()]
-        primes.extend(numbers)
-
-    # Step 3: Convert the list of primes to a JSON array
-    primes_json = json.dumps(primes, indent=4)
-
-    return primes_json
-
-# Example usage:
-file_path = 'primes1.txt'
-primes_json = convert_primes_to_json(file_path)
-print(primes_json)
-
-# If you want to save the JSON array to a file:
-output_path = 'primes1.json'
-with open(output_path, 'w') as output_file:
-    output_file.write(primes_json)

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

src/is_prime.rs

@@ -1,76 +1,73 @@
-pub mod prime_utils {
-    use num::{BigUint, One};
-    use once_cell::sync::Lazy;
 
-    #[must_use]
+
-    pub fn log_2(x: &BigUint) -> u64 {
+pub mod prime_utils {
+    use num::{BigUint, One, Zero};
+
+    use crate::primality_test::primality_tests::is_probably_prime;
+
+    #[must_use] pub fn log_2(x: &BigUint) -> u64 {
         x.bits() - 1
     }
-
+    
-    static FOUR: Lazy<BigUint> = Lazy::new(|| BigUint::from(4u8));
+    #[must_use] pub fn is_prime(number: &BigUint, g_primes: &Vec<BigUint>) -> bool {
-    static TWO: Lazy<BigUint> = Lazy::new(|| BigUint::from(2u8));
+        if BigUint::from(1u8) == *number {
-    static ONE: Lazy<BigUint> = Lazy::new(BigUint::one);
-    const ZERO: BigUint = BigUint::ZERO;
-
-    #[must_use]
-    pub fn is_prime(number: &BigUint) -> bool {
-        if &*ONE >= number {
             return false;
         }
-        if &*FOUR > number {
+        if BigUint::from(4u8) > *number  {
             return true;
         }
-        if !number.bit(0) {
+
+        if number.sqrt().pow(2) == *number {
             return false;
         }
-
+    
-        // mersenne numbers = 2^a - 1
+        let two = BigUint::from(2u8);
+    
+        // number = 2^a - 1
         // a = log2(number + 1)
-        let a = log_2(&(number + 1u8));
+        let a = log_2(&(number+1u8));
+        if BigUint::from(2u8).pow(a as u32)-BigUint::one() != *number {
+            let mut i = BigUint::one();
+            let one = BigUint::one();
+            let zero = BigUint::zero();
+            
+            let sqrtnum = number.sqrt()+&one; //fake ceil function
 
-        let is_mersenne = {
+            if let Some(max_value) = g_primes.iter().max() {
-            let num_p2 = {
+                 if max_value > &sqrtnum {
-                let mut num = BigUint::default();
+                     for prime in g_primes {
-                num.set_bit(a, true);
+                        if prime<&sqrtnum && number%prime == zero {
-                num
+                            return false;
-            };
+                        }
-            assert!(num_p2 > BigUint::one());
+                     }
-
+                }
-            let num_p2 = num_p2 - &*ONE;
-
-            &num_p2 == number
-        };
-
-        if is_mersenne {
-            return mersenne_check(number, a);
-        }
-
-        let sqrtnum = number.sqrt() + &*ONE; //fake ceil function
-
-        inner_prime(number, &sqrtnum)
-    }
-
-    fn mersenne_check(number: &BigUint, a: u64) -> bool {
-        let mut last = FOUR.clone();
-
-        for _ in 2..a {
-            last = (last.pow(2) - &*TWO) % number;
-        }
-
-        last == ZERO
-    }
-
-    fn inner_prime(number: &BigUint, sqrtnum: &BigUint) -> bool {
-        let mut i = BigUint::one();
-
-        loop {
-            i += &*TWO; //we begin checking 3 and then continue with every second number as every even number is divisible by 2 and we already checked that
-            if &i >= sqrtnum {
-                return true;
             }
-            if number % &i == ZERO {
+
+            if !is_probably_prime(number,5) {
                 return false;
             }
+
+            loop {
+                i += &one;
+                if number%&i == zero {
+                    return false;
+                }
+                if i == sqrtnum {
+                    return true;
+                }
+            }
+
+            
         }
+    
+        // 4 12 194
+        let mut last = BigUint::from(4u8);
+        
+        for _i in 2..a {
+            last = (last.pow(2)-&two)%number;
+        }
+
+        last == BigUint::from(0u8)
     }
 }
+

src/main.rs

@@ -1,32 +1,29 @@
 #![warn(clippy::perf)]
 #![warn(clippy::all)]
 
-mod is_prime;
 
-use crate::is_prime::prime_utils;
+pub mod is_prime;
+pub mod primality_test;
+
+use std::{time::SystemTime,thread, io::Write};
 use num::{BigUint, One};
-use std::{
+use crate::is_prime::prime_utils;
-    env::args,
+use thread_priority::{set_current_thread_priority,ThreadPriority};
-    io::Write,
-    sync::{
-        atomic::{AtomicU64, AtomicUsize},
-        Arc, Mutex,
-    },
-    thread,
-    time::{Instant, SystemTime},
-};
 
 fn p(n: f64) -> f64 {
     let ln_n = n.ln();
     let ln_ln_n = ln_n.ln();
     let ln_ln_ln_n = ln_ln_n.ln();
 
-    n * (ln_n + ln_ln_n - 1.0 + (ln_ln_ln_n - 2.0) / ln_n
+    n * (
-        - ((ln_ln_n).powi(2) - 6.0 * ln_ln_n + 11.0) / (2.0 * ln_n)
+        ln_n + ln_ln_n - 1.0
-        + ((ln_ln_n / ln_n).powi(3)) * (1.0 / ln_n))
+        + (ln_ln_ln_n - 2.0) / ln_n
+        - ((ln_ln_n).powi(2) - 6.0 * ln_ln_n + 11.0) / (2.0 * 2.0f64.log2() * ln_n)
+        + ((ln_ln_n / ln_n).powi(3)) * (1.0 / ln_n)
+    )
 }
 
-fn to_usize(f: f64) -> usize {
+fn to_usize(f:f64) -> usize {
     let rounded_num: i64 = f.round() as i64;
     if rounded_num >= 0 {
         rounded_num as usize
@@ -35,160 +32,161 @@ fn to_usize(f: f64) -> usize {
     }
 }
 
-#[cfg(target_os = "windows")]
+fn to_f64(u:usize) -> f64 {
-fn try_set_thread_priority() {
+    f64::from_bits(u as u64)
-    use thread_priority::{set_current_thread_priority, ThreadPriority};
+}
 
-    if let Err(e) = set_current_thread_priority(ThreadPriority::Max) {
+fn try_set_thread_priority() {
+    if set_current_thread_priority(ThreadPriority::Max).is_err() {
         eprintln!("[WARN] failed to set thread priority to max");
-        eprintln!("{e}");
     }
 }
 
 fn write_primes(primes: &[BigUint]) {
-    let primes: Vec<String> = primes
-        .iter()
-        .map(std::string::ToString::to_string)
-        .collect();
-
     let mut file = std::fs::File::create("primes.json").unwrap();
-    file.write_all(serde_json::to_string(&primes).unwrap().as_bytes())
+    file.write_all(b"[").unwrap();
-        .unwrap();
+    let mut it = primes.iter().peekable();
-}
+    while let Some(prime) = it.next() {
-
+        file.write_all(prime.to_string().as_bytes()).unwrap();
-const N: i64 = 1_000_000;
+        if it.peek().is_some() {
-const NF: f64 = N as f64;
+            file.write_all(b",").unwrap();
-const NU: usize = N as usize;
-const THREADS: usize = 30;
-
-fn worker(
-    workloads: usize,
-    i: usize,
-    progress: &AtomicU64,
-    arcclone: &Arc<Mutex<Vec<BigUint>>>,
-    threads_done: &AtomicUsize,
-) {
-    #[cfg(target_os = "windows")]
-    try_set_thread_priority();
-
-    let work_uint = BigUint::from(workloads);
-    let mut number = BigUint::from(i) * &work_uint;
-
-    let max = BigUint::from(i + 1) * work_uint;
-    let mut primecache = Vec::with_capacity(NU);
-    loop {
-        number += &BigUint::one();
-
-        if prime_utils::is_prime(&number) {
-            primecache.push(number.clone());
-            progress.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-        }
-        if number == max {
-            break;
         }
     }
-
+    file.write_all(b"]").unwrap();
-    arcclone.lock().unwrap().append(&mut primecache);
-
-    threads_done.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
 }
 
+
+/* 
+    let mut buffer = String::new();
+    let stdin = io::stdin();
+    print!("please enter the number to check: ");
+    io::stdout().flush().expect("could not flush");
+    stdin.read_line(&mut buffer).expect("could not read from stdin");
+    buffer = buffer.trim().to_owned();
+    
+    let number = BigUint::parse_bytes(&buffer.as_bytes(), 10).expect("expected positive number");
+
+    if is_prime(number.clone()) {
+        println!("\n{number} is a prime");
+    } else {
+        println!("\n{number} is not a prime");
+    }
+    */
 fn main() {
-    if let Some(prime) = args().nth(1) {
+    const N:i64 = 100_000;
-        use std::str::FromStr;
+    const NU:usize = N as usize;
-        let prime = BigUint::from_str(&prime).unwrap();
+    const THREADS: usize = 12;
+    const SPLITTER: u128 = 10000u128;
 
-        let is_prime = is_prime::prime_utils::is_prime(&prime);
+    try_set_thread_priority();
-
-        println!("Number is {}a prime", if is_prime { "" } else { "not " });
-
-        return;
-    }
 
     let sys_time = SystemTime::now();
 
-    let nthprime_approx: usize = to_usize(p(NF * 1.02));
+    let nf:f64 = 100_000f64;
+    let nthprime_approx:usize = to_usize(p(nf*1.02));
+    
+    let workloads = nthprime_approx/THREADS;
 
-    let workloads = nthprime_approx / THREADS;
+    let primecache: Vec<BigUint> = vec![];
-
-    let primecache: Vec<BigUint> = Vec::with_capacity(NU);
     let primemutex = std::sync::Mutex::new(primecache);
     let primearc = std::sync::Arc::new(primemutex);
+    let mut joins = vec![];
+    for i in 0..THREADS {
+        let arcclone = primearc.clone();
+        let handle = thread::spawn(move || {
 
-    let progress_val = AtomicU64::new(0);
+            try_set_thread_priority();
-    let progress = &progress_val;
 
-    let threads_done_val = AtomicUsize::new(0);
+            let one_thousand = &BigUint::from(SPLITTER*10);
-    let threads_done = &threads_done_val;
+            let one_hundred = &BigUint::from(SPLITTER);
+            let ten = &BigUint::from(10u8);
 
-    thread::scope(|scope| {
+            let work_uint = BigUint::from(workloads);
-        for i in 0..THREADS {
+            let mut number = BigUint::from(i)*&work_uint;
-            let arcclone = primearc.clone();
+            let inc = BigUint::one();
-            scope.spawn(move || worker(workloads, i, progress, &arcclone, threads_done));
+            
-        }
+            let max = BigUint::from(i+1)*work_uint;
-
+            let mut primecache = vec![];
-        let mut last_progress = Instant::now();
+            loop {
-
+                number += &inc;
-        loop {
+                
-            let threads_completed = threads_done.load(std::sync::atomic::Ordering::Relaxed);
+                if prime_utils::is_prime(&number,&primecache) {
-
+                    primecache.push(number.clone());
-            if threads_completed == THREADS {
+                }
-                break;
+                if (&number * one_thousand)/&max/ten == &number/&max*one_hundred {
-            }
+                    let tried_getting = SystemTime::now();
-
+                    let mut new_primecache = arcclone.lock().unwrap();
-            if last_progress.elapsed().as_millis() >= 500 {
+                    if SystemTime::now().duration_since(tried_getting).unwrap().as_millis() > 50 {
-                last_progress = Instant::now();
+                        eprintln!("[WARN] Waited 0.05+ seconds for lock!");
-
+                    }
-                let n = progress.load(std::sync::atomic::Ordering::Relaxed);
+                    new_primecache.append(&mut primecache);
-
+                    new_primecache.sort();
-                println!(
+                    new_primecache.dedup();
-                    "Progress: {:0>width$}/{} ({:>3}%) | {:0>t_width$}",
+                    
-                    n,
+                    primecache = new_primecache.clone();
-                    N,
+                    
-                    (n as f64 / NF * 100.0).min(100.0).floor(),
+                }
-                    threads_completed,
+                if number == max {
-                    width = N.to_string().len(),
-                    t_width = THREADS.to_string().len()
-                );
-            }
-
-            std::thread::sleep(std::time::Duration::from_millis(100));
-        }
-    });
-
-    let mut primes = primearc.lock().unwrap();
-    primes.sort_unstable();
-
-    let removed = primes.len() - NU;
-    primes.truncate(NU);
-
-    let added = NU - primes.len();
-    if primes.len() < NU {
-        let inc = BigUint::from(2u8);
-
-        println!("[INFO] less primes than expected");
-        let mut number = BigUint::from(THREADS) * BigUint::from(workloads);
-        if &number % &inc == BigUint::ZERO {
-            number += BigUint::one();
-        }
-        loop {
-            number += &inc;
-            if prime_utils::is_prime(&number) {
-                primes.push(number.clone());
-                if primes.len() == NU {
                     break;
                 }
+            }   
+
+            let mut new_primecache = arcclone.lock().unwrap();
+            new_primecache.append(&mut primecache);
+            new_primecache.sort();
+            new_primecache.dedup();
+        });
+        joins.push(handle);
+    }
+
+    for handle in joins {
+        handle.join().unwrap();
+    }
+
+    let mut primes = primearc.lock().unwrap().to_vec();
+
+    let removed:i32 = if primes.len() > NU {
+        let mut rem = 0;
+        loop {
+            if primes.len() <= NU {
+                break;
+            }
+            rem+=1;
+            primes.pop();
+        }
+        rem
+    } else {
+        0
+    };
+
+    let added = NU-primes.len();
+    if primes.len() < NU {
+        println!("[INFO] less primes than expected");
+        let mut number = BigUint::from(THREADS)*BigUint::from(workloads);
+        let inc = BigUint::one();
+        loop {
+            number += &inc;
+            if prime_utils::is_prime(&number, &primes) {
+                primes.push(number.clone());
+            }
+            if primes.len() == NU {
+                break;
             }
         }
     }
 
-    let difference = sys_time.elapsed().unwrap();
+    let new_sys_time = SystemTime::now();
+    let difference = new_sys_time.duration_since(sys_time)
+    .expect("Clock may have gone backwards");
 
-    assert_eq!(primes.len(), NU);
+    assert_eq!(primes.len(),NU);
 
-    println!("primes added: {added} | removed: {removed}");
+    println!("primes added: {added} | % added: {}% | removed: {removed}",to_f64(added)/to_f64(primes.len())*100.0);
     println!("time: {difference:?}");
     println!("writing primes...");
 
     write_primes(&primes);
+
+
+
 }

src/primality_test.rs

@@ -0,0 +1,60 @@
+pub mod primality_tests {
+    use num::{BigUint, Integer, One, Zero};
+    use rand::RngCore;
+
+    fn generate_random_biguint(num_bits: usize) -> BigUint {
+        let mut rng = rand::thread_rng();
+        let bytes = num_bits / 8 + 1;
+        let mut buf = vec![0u8; bytes];
+        rng.fill_bytes(&mut buf);
+        BigUint::from_bytes_be(&buf)
+    }
+
+    
+    pub fn is_probably_prime(number: &BigUint, iterations: u32) -> bool {
+        if number <= &BigUint::one() || number == &BigUint::from(4u32) {
+            return false;
+        } else if number <= &BigUint::from(3u32) {
+            return true;
+        }
+        let one = BigUint::one();
+        let mut d = number - &one;
+        while d.is_even() {
+            d /= 2u32;
+        }
+        for _ in 0..iterations {
+            let a = generate_random_biguint((number.bits()-1) as usize);
+            let mut x = mod_exp(a.clone(), &d, number);
+            if x == one || x == number - &one {
+                continue;
+            }
+            let mut continue_loop = false;
+            for _ in 0..(number.bits() - 1) {
+                x = mod_exp(x.clone(), &BigUint::from(2u32), number);
+                if x == number - &one {
+                    continue_loop = true;
+                    break;
+                }
+            }
+            if !continue_loop {
+                return false;
+            }
+        }
+        true
+    }
+    
+    fn mod_exp(mut base: BigUint, ex: &BigUint, modulus: &BigUint) -> BigUint {
+        let mut exp = ex.clone();
+        let mut result = BigUint::one();
+        base %= modulus;
+        while !exp.is_zero() {
+            if exp.is_odd() {
+                result = (&result * &base) % modulus;
+            }
+            base = base.pow(2) % modulus;
+            exp /= 2u32;
+        }
+        result
+    }
+    
+}