/** * It uses the sieve of Eratosthenes to discard several composite numbers in * some appropriate range (at the moment {@code [this, this + 1024]}). After * this process it applies the Miller-Rabin test to the numbers that were * not discarded in the sieve. * * @see BigInteger#nextProbablePrime() * @see #millerRabin(BigInteger, int) */ public static BigInteger NextProbablePrime(BigInteger n) { // PRE: n >= 0 int i, j; int certainty; int gapSize = 1024; // for searching of the next probable prime number int[] modules = new int[primes.Length]; bool[] isDivisible = new bool[gapSize]; BigInteger startPoint; BigInteger probPrime; // If n < "last prime of table" searches next prime in the table if ((n.numberLength == 1) && (n.Digits[0] >= 0) && (n.Digits[0] < primes[primes.Length - 1])) { for (i = 0; n.Digits[0] >= primes[i]; i++) { ; } return(BIprimes[i]); } /* * Creates a "N" enough big to hold the next probable prime Note that: N < * "next prime" < 2*N */ startPoint = new BigInteger(1, n.numberLength, new int[n.numberLength + 1]); Array.Copy(n.Digits, 0, startPoint.Digits, 0, n.numberLength); // To fix N to the "next odd number" if (BigInteger.TestBit(n, 0)) { Elementary.inplaceAdd(startPoint, 2); } else { startPoint.Digits[0] |= 1; } // To set the improved certainly of Miller-Rabin j = startPoint.BitLength; for (certainty = 2; j < BITS[certainty]; certainty++) { ; } // To calculate modules: N mod p1, N mod p2, ... for first primes. for (i = 0; i < primes.Length; i++) { modules[i] = Division.Remainder(startPoint, primes[i]) - gapSize; } while (true) { // At this point, all numbers in the gap are initialized as // probably primes // Arrays.fill(isDivisible, false); for (int k = 0; k < isDivisible.Length; k++) { isDivisible[k] = false; } // To discard multiples of first primes for (i = 0; i < primes.Length; i++) { modules[i] = (modules[i] + gapSize) % primes[i]; j = (modules[i] == 0) ? 0 : (primes[i] - modules[i]); for (; j < gapSize; j += primes[i]) { isDivisible[j] = true; } } // To execute Miller-Rabin for non-divisible numbers by all first // primes for (j = 0; j < gapSize; j++) { if (!isDivisible[j]) { probPrime = startPoint.Copy(); Elementary.inplaceAdd(probPrime, j); if (MillerRabin(probPrime, certainty)) { return(probPrime); } } } Elementary.inplaceAdd(startPoint, gapSize); } }
private static bool TryParse(string s, int radix, out BigInteger value, out Exception exception) { if (String.IsNullOrEmpty(s)) { exception = new FormatException(Messages.math11); value = null; return(false); } if ((radix < CharHelper.MIN_RADIX) || (radix > CharHelper.MAX_RADIX)) { // math.11=Radix out of range exception = new FormatException(Messages.math12); value = null; return(false); } int sign; int[] digits; int numberLength; int stringLength = s.Length; int startChar; int endChar = stringLength; if (s[0] == '-') { sign = -1; startChar = 1; stringLength--; } else { sign = 1; startChar = 0; } /* * We use the following algorithm: split a string into portions of n * char and convert each portion to an integer according to the * radix. Then convert an exp(radix, n) based number to binary using the * multiplication method. See D. Knuth, The Art of Computer Programming, * vol. 2. */ try { int charsPerInt = Conversion.digitFitInInt[radix]; int bigRadixDigitsLength = stringLength / charsPerInt; int topChars = stringLength % charsPerInt; if (topChars != 0) { bigRadixDigitsLength++; } digits = new int[bigRadixDigitsLength]; // Get the maximal power of radix that fits in int int bigRadix = Conversion.bigRadices[radix - 2]; // Parse an input string and accumulate the BigInteger's magnitude int digitIndex = 0; // index of digits array int substrEnd = startChar + ((topChars == 0) ? charsPerInt : topChars); int newDigit; for (int substrStart = startChar; substrStart < endChar; substrStart = substrEnd, substrEnd = substrStart + charsPerInt) { int bigRadixDigit = Convert.ToInt32(s.Substring(substrStart, substrEnd - substrStart), radix); newDigit = Multiplication.MultiplyByInt(digits, digitIndex, bigRadix); newDigit += Elementary.inplaceAdd(digits, digitIndex, bigRadixDigit); digits[digitIndex++] = newDigit; } numberLength = digitIndex; } catch (Exception ex) { exception = ex; value = null; return(false); } value = new BigInteger(); value.sign = sign; value.numberLength = numberLength; value.digits = digits; value.CutOffLeadingZeroes(); exception = null; return(true); }
/** * Calculates a.modInverse(p) Based on: Savas, E; Koc, C "The Montgomery Modular * Inverse - Revised" */ public static BigInteger ModInverseMontgomery(BigInteger a, BigInteger p) { if (a.Sign == 0) { // ZERO hasn't inverse // math.19: BigInteger not invertible throw new ArithmeticException(Messages.math19); } if (!BigInteger.TestBit(p, 0)) { // montgomery inverse require even modulo return(ModInverseLorencz(a, p)); } int m = p.numberLength * 32; // PRE: a \in [1, p - 1] BigInteger u, v, r, s; u = p.Copy(); // make copy to use inplace method v = a.Copy(); int max = System.Math.Max(v.numberLength, u.numberLength); r = new BigInteger(1, 1, new int[max + 1]); s = new BigInteger(1, 1, new int[max + 1]); s.Digits[0] = 1; // s == 1 && v == 0 int k = 0; int lsbu = u.LowestSetBit; int lsbv = v.LowestSetBit; int toShift; if (lsbu > lsbv) { BitLevel.InplaceShiftRight(u, lsbu); BitLevel.InplaceShiftRight(v, lsbv); BitLevel.InplaceShiftLeft(r, lsbv); k += lsbu - lsbv; } else { BitLevel.InplaceShiftRight(u, lsbu); BitLevel.InplaceShiftRight(v, lsbv); BitLevel.InplaceShiftLeft(s, lsbu); k += lsbv - lsbu; } r.Sign = 1; while (v.Sign > 0) { // INV v >= 0, u >= 0, v odd, u odd (except last iteration when v is even (0)) while (u.CompareTo(v) > BigInteger.EQUALS) { Elementary.inplaceSubtract(u, v); toShift = u.LowestSetBit; BitLevel.InplaceShiftRight(u, toShift); Elementary.inplaceAdd(r, s); BitLevel.InplaceShiftLeft(s, toShift); k += toShift; } while (u.CompareTo(v) <= BigInteger.EQUALS) { Elementary.inplaceSubtract(v, u); if (v.Sign == 0) { break; } toShift = v.LowestSetBit; BitLevel.InplaceShiftRight(v, toShift); Elementary.inplaceAdd(s, r); BitLevel.InplaceShiftLeft(r, toShift); k += toShift; } } if (!u.IsOne) { // in u is stored the gcd // math.19: BigInteger not invertible. throw new ArithmeticException(Messages.math19); } if (r.CompareTo(p) >= BigInteger.EQUALS) { Elementary.inplaceSubtract(r, p); } r = p - r; // Have pair: ((BigInteger)r, (Integer)k) where r == a^(-1) * 2^k mod (module) int n1 = CalcN(p); if (k > m) { r = MonPro(r, BigInteger.One, p, n1); k = k - m; } r = MonPro(r, BigInteger.GetPowerOfTwo(m - k), p, n1); return(r); }