C# IBigInteger.TestBit方法代码示例

        private static ECPoint ImplShamirsTrick(ECPoint p, IBigInteger k, ECPoint q, IBigInteger l)
        {
            var m = System.Math.Max(k.BitLength, l.BitLength);
            var z = p.Add(q);
            var r = p.Curve.Infinity;

            for (var i = m - 1; i >= 0; --i)
            {
                r = r.Twice();

                if (k.TestBit(i))
                {
                    r = r.Add(l.TestBit(i) ? z : p);
                }
                else
                {
                    if (l.TestBit(i))
                    {
                        r = r.Add(q);
                    }
                }
            }

            return r;
        }

 /**
 * Simple shift-and-add multiplication. Serves as reference implementation
 * to verify (possibly faster) implementations in
 * {@link org.bouncycastle.math.ec.ECPoint ECPoint}.
 *
 * @param p The point to multiply.
 * @param k The factor by which to multiply.
 * @return The result of the point multiplication <code>k * p</code>.
 */
 public ECPoint Multiply(ECPoint p, IBigInteger k, IPreCompInfo preCompInfo)
 {
     ECPoint q = p.Curve.Infinity;
     int t = k.BitLength;
     for (int i = 0; i < t; i++)
     {
         if (k.TestBit(i))
         {
             q = q.Add(p);
         }
         p = p.Twice();
     }
     return q;
 }

        public DHParameters(
            IBigInteger p,
            IBigInteger g,
            IBigInteger q,
			int						m,
			int						l,
            IBigInteger j,
			DHValidationParameters	validation)
        {
            if (p == null)
                throw new ArgumentNullException("p");
            if (g == null)
                throw new ArgumentNullException("g");
            if (!p.TestBit(0))
                throw new ArgumentException(@"field must be an odd prime", "p");
            if (g.CompareTo(BigInteger.Two) < 0
                || g.CompareTo(p.Subtract(BigInteger.Two)) > 0)
                throw new ArgumentException(@"generator must in the range [2, p - 2]", "g");
            if (q != null && q.BitLength >= p.BitLength)
                throw new ArgumentException(@"q too big to be a factor of (p-1)", "q");
            if (m >= p.BitLength)
                throw new ArgumentException(@"m value must be < bitlength of p", "m");
            if (l != 0)
            {
                if (l >= p.BitLength)
                    throw new ArgumentException(@"when l value specified, it must be less than bitlength(p)", "l");
                if (l < m)
                    throw new ArgumentException(@"when l value specified, it may not be less than m value", "l");
            }
            if (j != null && j.CompareTo(BigInteger.Two) < 0)
                throw new ArgumentException(@"subgroup factor must be >= 2", "j");

            // TODO If q, j both provided, validate p = jq + 1 ?

            this.p = p;
            this.g = g;
            this.q = q;
            this.m = m;
            this.l = l;
            this.j = j;
            this.validation = validation;
        }

        /**
        * Computes the Window NAF (non-adjacent Form) of an integer.
        * @param width The width <code>w</code> of the Window NAF. The width is
        * defined as the minimal number <code>w</code>, such that for any
        * <code>w</code> consecutive digits in the resulting representation, at
        * most one is non-zero.
        * @param k The integer of which the Window NAF is computed.
        * @return The Window NAF of the given width, such that the following holds:
        * <code>k = &#8722;<sub>i=0</sub><sup>l-1</sup> k<sub>i</sub>2<sup>i</sup>
        * </code>, where the <code>k<sub>i</sub></code> denote the elements of the
        * returned <code>sbyte[]</code>.
        */
        public sbyte[] WindowNaf(sbyte width, IBigInteger k)
        {
            // The window NAF is at most 1 element longer than the binary
            // representation of the integer k. sbyte can be used instead of short or
            // int unless the window width is larger than 8. For larger width use
            // short or int. However, a width of more than 8 is not efficient for
            // m = log2(q) smaller than 2305 Bits. Note: Values for m larger than
            // 1000 Bits are currently not used in practice.
            sbyte[] wnaf = new sbyte[k.BitLength + 1];

            // 2^width as short and BigInteger
            short pow2wB = (short)(1 << width);
            IBigInteger pow2wBI = BigInteger.ValueOf(pow2wB);

            int i = 0;

            // The actual length of the WNAF
            int length = 0;

            // while k >= 1
            while (k.SignValue > 0)
            {
                // if k is odd
                if (k.TestBit(0))
                {
                    // k Mod 2^width
                    IBigInteger remainder = k.Mod(pow2wBI);

                    // if remainder > 2^(width - 1) - 1
                    if (remainder.TestBit(width - 1))
                    {
                        wnaf[i] = (sbyte)(remainder.IntValue - pow2wB);
                    }
                    else
                    {
                        wnaf[i] = (sbyte)remainder.IntValue;
                    }
                    // wnaf[i] is now in [-2^(width-1), 2^(width-1)-1]

                    k = k.Subtract(BigInteger.ValueOf(wnaf[i]));
                    length = i;
                }
                else
                {
                    wnaf[i] = 0;
                }

                // k = k/2
                k = k.ShiftRight(1);
                i++;
            }

            length++;

            // Reduce the WNAF array to its actual length
            sbyte[] wnafShort = new sbyte[length];
            Array.Copy(wnaf, 0, wnafShort, 0, length);
            return wnafShort;
        }

        private static IBigInteger[] FastLucasSequence(IBigInteger p, IBigInteger P, IBigInteger Q, IBigInteger k)
        {
            // TODO Research and apply "common-multiplicand multiplication here"

            var n = k.BitLength;
            var s = k.GetLowestSetBit();

            Debug.Assert(k.TestBit(s));

            var uh = BigInteger.One;
            var vl = BigInteger.Two;
            var vh = P;
            var ql = BigInteger.One;
            var qh = BigInteger.One;

            for (var j = n - 1; j >= s + 1; --j)
            {
                ql = ql.Multiply(qh).Mod(p);

                if (k.TestBit(j))
                {
                    qh = ql.Multiply(Q).Mod(p);
                    uh = uh.Multiply(vh).Mod(p);
                    vl = vh.Multiply(vl).Subtract(P.Multiply(ql)).Mod(p);
                    vh = vh.Multiply(vh).Subtract(qh.ShiftLeft(1)).Mod(p);
                }
                else
                {
                    qh = ql;
                    uh = uh.Multiply(vl).Subtract(ql).Mod(p);
                    vh = vh.Multiply(vl).Subtract(P.Multiply(ql)).Mod(p);
                    vl = vl.Multiply(vl).Subtract(ql.ShiftLeft(1)).Mod(p);
                }
            }

            ql = ql.Multiply(qh).Mod(p);
            qh = ql.Multiply(Q).Mod(p);
            uh = uh.Multiply(vl).Subtract(ql).Mod(p);
            vl = vh.Multiply(vl).Subtract(P.Multiply(ql)).Mod(p);
            ql = ql.Multiply(qh).Mod(p);

            for (var j = 1; j <= s; ++j)
            {
                uh = uh.Multiply(vl).Mod(p);
                vl = vl.Multiply(vl).Subtract(ql.ShiftLeft(1)).Mod(p);
                ql = ql.Multiply(ql).Mod(p);
            }

            return new[] { uh, vl };
        }