/** * The Factor Base size B is given by (e ^ (sqrt(r))) ^ (sqrt(2)/4) * * Where r = ln(n) * ln(ln(n)) * * Even for numbers in the millions of trillions, r ends up being very small, so in order to do exact math we assume r can fit inside a double. * * Since we must have an integer number of factor bases, we take the floor of B. **/ public static int getFactorBaseSize(BigInteger number_to_factor) { double r = BigInteger.Log(number_to_factor) * (BigInteger.Log(BigIntegerWrapper.Log(number_to_factor))); double exact_value = Math.Pow(Math.Pow(Math.E, Math.Sqrt(r)), (Math.Sqrt(2) / 4)); return((int)Math.Floor(exact_value)); }
public static int SieveofSundaramSerial(BigInteger to_factor) { if (BigIntegerWrapper.SqRt(to_factor) < int.MaxValue - 1) { int BAsize = (int)BigIntegerWrapper.SqRt(to_factor); int k = BAsize / 2; BitArray tracker = new BitArray(BAsize); /* SET ALL TO PRIME STATUS */ tracker.SetAll(true); int maxVal = 0; int denominator = 0; Stopwatch sundaram_serial = new Stopwatch(); sundaram_serial.Start(); for (int i = 1; i < k; i++) { denominator = (i << 1) + 1; maxVal = (k - i) / denominator; for (int j = i; j <= maxVal; j++) { tracker[i + j * denominator] = false; } } sundaram_serial.Stop(); Stopwatch serielsearch = new Stopwatch(); serielsearch.Start(); int dummy = 0; for (int i = 1; i < k; i++) { if (tracker[i]) { dummy = (i << 1) + 1; // dummy contains prime number.The code is here not ignore the prime number calcuation part. if (to_factor % dummy == 0) { break; } } } serielsearch.Stop(); Console.WriteLine("search runtime: " + serielsearch.ElapsedMilliseconds + "ms."); Console.WriteLine("Serial Sieve of Sundaram Runtime: " + sundaram_serial.ElapsedMilliseconds + "ms."); return(dummy); } else { Console.WriteLine("Too big to factor with Sieve of Sundaram. "); return(-1); } }
public static BigInteger computeQX(BigInteger x, BigInteger n) { return(BigInteger.Pow((x + BigIntegerWrapper.SqRt(n)), 2) % n); }
public static int SieveofSundaramParallel(BigInteger to_factor) { if (BigIntegerWrapper.SqRt(to_factor) < int.MaxValue - 1) { int BAsize = (int)BigIntegerWrapper.SqRt(to_factor); int k = BAsize / 2; BitArray tracker = new BitArray(BAsize); /* SET ALL TO PRIME STATUS */ tracker.SetAll(true); int maxVal = 0; int denominator = 0; Stopwatch sundaram_parallel = new Stopwatch(); sundaram_parallel.Start(); for (int i = 1; i < k; i++) { denominator = (i << 1) + 1; maxVal = (k - i) / denominator; /*Parallel.For(i, maxVal, new ParallelOptions { MaxDegreeOfParallelism = 2 }, (j, state) => * { * tracker[i + j * denominator] = false; * });*/ for (int j = i; j <= maxVal; j++) { tracker[i + j * denominator] = false; } } sundaram_parallel.Stop(); Stopwatch parallelSearch = new Stopwatch(); parallelSearch.Start(); int dummy = 0; int final = 0; Parallel.For(1, k, new ParallelOptions { MaxDegreeOfParallelism = 4 }, (i, state) => { if (tracker[i]) { dummy = (i << 1) + 1; // dummy contains prime number.The code is here not ignore the prime number calcuation part. if (to_factor % dummy == 0) { final = dummy; state.Break(); } } }); parallelSearch.Stop(); Console.WriteLine("search runtime: " + parallelSearch.ElapsedMilliseconds + "ms."); Console.WriteLine("Parallel Sieve of Sundaram Runtime: " + sundaram_parallel.ElapsedMilliseconds + "ms."); return(final); } else { Console.WriteLine("Too big to factor with Sieve of Sundaram. "); return(-1); } }
public BigInteger[] getFactorsSerial() { BigInteger p = 1997333137; BigInteger q = 2106945901; BigInteger integer_to_factor = p * q; Console.WriteLine("p value: " + p); Console.WriteLine("q value: " + q); BigInteger[] bruteforce_Serial = LeedamKeyson.factorModulusSerial(integer_to_factor); Console.WriteLine("brute force serial p value: " + bruteforce_Serial[0]); Console.WriteLine("brute force serial q value: " + bruteforce_Serial[1]); BigInteger[] bruteforce_Parallel = LeedamKeyson.factorModulusParallel(integer_to_factor); Console.WriteLine("brute force parallel p value: " + bruteforce_Parallel[0]); //Console.WriteLine("brute force parallel q value" + bruteforce_Parallel[1]); int factor_serial = QuadraticSieveFunctions.SieveofSundaramSerial(integer_to_factor); Console.WriteLine("Serial returns the p value: " + factor_serial); Console.WriteLine("Serial returns the q value: " + (integer_to_factor / factor_serial)); int factor_parallel = QuadraticSieveFunctions.SieveofSundaramParallel(integer_to_factor); Console.WriteLine("Parallel returns the p value: " + factor_parallel); Console.WriteLine("Parallel returns the q value: " + (integer_to_factor / factor_parallel)); int factor_base_size = QuadraticSieveFunctions.getFactorBaseSize(integer_to_factor); factor_base_size = (int)BigIntegerWrapper.SqRt(integer_to_factor); BigInteger sieve_interval_upper = QuadraticSieveFunctions.getSieveInterval(factor_base_size); int[] factor_base = QuadraticSieveFunctions.SieveOfErastosthenesSerial(factor_base_size); factor_base = new int[] { 0 }; factor_base = QuadraticSieveFunctions.SieveOfErastosthenesParallel(factor_base_size); int[] quadratic_residues = QuadraticSieveFunctions.getResiduesSerial(factor_base, integer_to_factor); BigInteger sieve_interval = QuadraticSieveFunctions.getSieveInterval(factor_base_size); BigInteger sieve_interval_start = BigIntegerWrapper.SqRt(integer_to_factor); LinkedList <BigInteger[]> smooth_numbers = QuadraticSieveFunctions.SmoothNumberSieveSerial(integer_to_factor, quadratic_residues, sieve_interval_start, sieve_interval_start + sieve_interval); //int k = 100000000; //QuadraticSieveFunctions.getFactorBaseSize(integer_to_factor); //int test_factor_base_size = QuadraticSieveFunctions.getFactorBaseSize(k); int result = factorSerial(factor_base, integer_to_factor); int result2 = factorParallel(factor_base, integer_to_factor); //int[] factor_base_parallel_improved = QuadraticSieveFunctions.SieveOfErastosthenesParallelImproved(2 * k); //int[] factor_base_parallel = QuadraticSieveFunctions.SieveOfErastosthenesParallel(2*k); return(new BigInteger[] { result, (int)(sieve_interval_upper / result) }); }
public BigInteger BigRoot(BigInteger k, BigInteger integer_to_factor) { return(BigInteger.Pow((k + BigIntegerWrapper.SqRt(integer_to_factor)), 2) % integer_to_factor); }