C# BigInteger.testBit方法代码示例

        /**
         * It requires that all parameters be positive.
         *
         * @return {@code base<sup>exponent</sup> mod (2<sup>j</sup>)}.
         * @see BigInteger#modPow(BigInteger, BigInteger)
         */
        internal static BigInteger pow2ModPow(BigInteger baseJ, BigInteger exponent, int j)
        {
            // PRE: (base > 0), (exponent > 0) and (j > 0)
            BigInteger res = BigInteger.ONE;
            BigInteger e = exponent.copy();
            BigInteger baseMod2toN = baseJ.copy();
            BigInteger res2;
            /*
             * If 'base' is odd then it's coprime with 2^j and phi(2^j) = 2^(j-1);
             * so we can reduce reduce the exponent (mod 2^(j-1)).
             */
            if (baseJ.testBit(0)) {
                inplaceModPow2(e, j - 1);
            }
            inplaceModPow2(baseMod2toN, j);

            for (int i = e.bitLength() - 1; i >= 0; i--) {
                res2 = res.copy();
                inplaceModPow2(res2, j);
                res = res.multiply(res2);
                if (BitLevel.testBit(e, i)) {
                    res = res.multiply(baseMod2toN);
                    inplaceModPow2(res, j);
                }
            }
            inplaceModPow2(res, j);
            return res;
        }

        /**
         * 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)
         */
        internal 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]);
            java.lang.SystemJ.arraycopy(n.digits, 0, startPoint.digits, 0, n.numberLength);
            // To fix N to the "next odd number"
            if (n.testBit(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
                java.util.Arrays<Object>.fill(isDivisible, 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);
            }
        }

        /**
         * Calculates a.modInverse(p) Based on: Savas, E; Koc, C "The Montgomery Modular
         * Inverse - Revised"
         */
        internal static BigInteger modInverseMontgomery(BigInteger a, BigInteger p)
        {
            if (a.sign == 0){
                // ZERO hasn't inverse
                // math.19: BigInteger not invertible
                throw new ArithmeticException("BigInteger not invertible");
                }

            if (!p.testBit(0)){
                // montgomery inverse require even modulo
                return modInverseHars(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 = java.lang.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.getLowestSetBit();
            int lsbv = v.getLowestSetBit();
            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.signum() > 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.getLowestSetBit();
                    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.signum() == 0)
                        break;
                    toShift = v.getLowestSetBit();
                    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("BigInteger not invertible");
            }
            if (r.compareTo(p) >= BigInteger.EQUALS) {
                Elementary.inplaceSubtract(r, p);
            }

            r = p.subtract(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;
        }

        /**
         * @see BigInteger#isProbablePrime(int)
         * @see #millerRabin(BigInteger, int)
         * @ar.org.fitc.ref Optimizations: "A. Menezes - Handbook of applied
         *                  Cryptography, Chapter 4".
         */
        internal static bool isProbablePrime(BigInteger n, int certainty)
        {
            // PRE: n >= 0;
            if ((certainty <= 0) || ((n.numberLength == 1) && (n.digits[0] == 2))) {
                return true;
            }
            // To discard all even numbers
            if (!n.testBit(0)) {
                return false;
            }
            // To check if 'n' exists in the table (it fit in 10 bits)
            if ((n.numberLength == 1) && ((n.digits[0] & 0XFFFFFC00) == 0)) {
                return (java.util.Arrays<Object>.binarySearch(primes, n.digits[0]) >= 0);
            }
            // To check if 'n' is divisible by some prime of the table
            for (int i = 1; i < primes.Length; i++) {
                if (Division.remainderArrayByInt(n.digits, n.numberLength,
                        primes[i]) == 0) {
                    return false;
                }
            }
            // To set the number of iterations necessary for Miller-Rabin test
            int iJ;
            int bitLength = n.bitLength();

            for (iJ = 2; bitLength < BITS[iJ]; iJ++) {
                ;
            }
            certainty = java.lang.Math.min(iJ, 1 + ((certainty - 1) >> 1));

            return millerRabin(n, certainty);
        }