c-prime 0.1.3

use machine_prime::PRIME_TABLE;

/// More efficient primality for compile-time evaluation
const fn small_prime(x: u64) -> bool{
   if x==2{
      return true;
   }
   if x&1==0{
     return false;
   }
   let mut idx=0usize;
   
   while idx<256{
     let prod = PRIME_TABLE[idx].wrapping_mul(x);
     if prod <= PRIME_TABLE[idx+1]{
        return prod==1
     }
     idx+=2;
   }
   return true;
}

const fn bounded_search(mut x: u128, stride: u128) -> u128{
    loop{
     x= x.wrapping_add(stride);
     
     if x == 0 || x == u128::MAX{
       panic!("Exceeded bounds");
     }
     
     if x < 537289{
      let n = x as u64;
       if small_prime(n){
          return x;     
       }
     }
     else{
     if machine_prime::is_prime_128(x){
        return x;
     }
    } 
   }
}
/// slightly faster to eek out performance in compile-time evaluation
const fn bounded_search_64(mut x: u64, stride: u64) -> u64{
loop{
     x= x.wrapping_add(stride);
     
     if x == 0 || x == u64::MAX{
       panic!("Exceeded bounds");
     }
     
     if x < 537289{
       if small_prime(x){
          return x;     
       }
     }
     else{
     if machine_prime::is_prime(x){
        return x;
     }
    } 
   }
}

const fn next_prime_64(x: u64) -> u64{
     bounded_search_64(x,1)
}
/// Returns the next prime
pub const fn next_prime(x: u128) -> u128{
    bounded_search(x,1)
}

/// Returns the previous prime
pub const fn prev_prime(x: u128) -> u128{
   bounded_search(x,u128::MAX)
}

/// Initialises an  array of sequential 128-bit primes
///
/// An array is initialised with the primes sequentially from START. This can be calculated at compile time
pub const fn prime_array<const S: usize>(mut start: u128) -> [u128;S]{
    let mut counter = 0usize;
    let mut valarray : [u128;S] = [0u128;S];
    loop{
        start=next_prime(start);
        valarray[counter]=start;
        counter+=1;    
        if counter == S{
          return valarray;
        }
      }
}


/// Initialises an  array of sequential 64-bit primes
pub const fn prime_array_64<const S: usize>(mut start: u64) -> [u64;S]{
    let mut counter = 0usize;
    let mut valarray : [u64;S] = [0u64;S];
    loop{
        let interim = next_prime_64(start);
        start= interim;
        valarray[counter]=start;
        counter+=1;    
        if counter == S{
          return valarray;
        }
      }
}

/// Initialises an  array of sequential 32-bit primes
pub const fn prime_array_32<const S: usize>(mut start: u32) -> [u32;S]{
    let mut counter = 0usize;
    let mut valarray : [u32;S] = [0u32;S];
    loop{
         let interim = next_prime_64(start as u64);
        if interim >= 1u64<<32{
           panic!("Exceeded the datatype max");
        }
        start=interim as u32;
        valarray[counter]=start;
        counter+=1;    
        if counter == S{
          return valarray;
        }
      }
}

/// Initialises an  array of sequential 16-bit primes
pub const fn prime_array_16<const S: usize>(mut start: u16) -> [u16;S]{
    let mut counter = 0usize;
    let mut valarray : [u16;S] = [0u16;S];
    loop{
        
         let interim = next_prime_64(start as u64);
        if interim >= 1u64<<16{
           panic!("Exceeded the datatype max");
        }
        start=interim as u16;
        valarray[counter]=start;
        counter+=1;    
        if counter == S{
          return valarray;
        }
      }
}

/// Initialises an array of sequantial multiplicative inverses of primes over Z/2^64
pub const fn prime_inv_array_64<const S: usize>(mut start: u64) -> [u64;S]{
    let mut counter = 0usize;
    if start < 2{
       panic!("2 has no inverse over 2^64");
    }
    let mut valarray : [u64;S] = [0u64;S];
    loop{
        start=next_prime_64(start);
        valarray[counter]=machine_prime::mul_inv2(start);
        counter+=1;    
        if counter == S{
          return valarray;
        }
      }
}

/// Initialises an  array of sequential multiplicative inverses of primes over Z/2^128
pub const fn prime_inv_array<const S: usize>(mut start: u128) -> [u128;S]{
    let mut counter = 0usize;
    if start < 2{
       panic!("2 has no multiplicative inverse over 2^128");
    }
    let mut valarray : [u128;S] = [0u128;S];
    loop{
        start=next_prime(start);
        valarray[counter]=machine_prime::mul_inv2_128(start);
        counter+=1;    
        if counter == S{
          return valarray;
        }
      }
}