C# BigInteger.Negate方法代码示例

        /// <summary>
        /// MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function.
        /// They consist of a 4 byte big endian length field, followed by the stated number of bytes representing the number in big endian format (with a sign bit).
        /// </summary>
        /// <param name="value"></param>
        /// <param name="includeLength">Indicates whether the 4 byte length field should be included</param>
        /// <returns></returns>
        public static byte[] Encode(BigInteger value,bool includeLength=true)
        {
            if(value.Equals(BigInteger.Zero))
            {
                if(!includeLength)
                { return new byte[0]; }
                return new byte[] { 0x00,0x00,0x00,0x00 };
            }

            bool isNegative=value.CompareTo(BigInteger.Zero)<0;
            if(isNegative)
            { value=value.Negate(); }

            byte[] array=value.ToByteArray();
            int length=array.Length;
            if((array[0] & 0x80)==0x80)
            { length++; }

            if(includeLength)
            {
                byte[] result=new byte[length+4];
                Array.Copy(array,0,result,length-array.Length+3,array.Length);
                ((uint)length).ToByteArrayBe(result);

                if(isNegative)
                { result[4]|=0x80; }
                return result;
            }
            else
            {
                byte[] result;
                if(length!=array.Length)
                {
                    result=new byte[length];
                    Array.Copy(array,0,result,1,array.Length);
                }
                else
                { result=array; }

                if(isNegative)
                { result[0]|=0x80; }

                return result;
            }
        }

        /// <summary>
        /// MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function.
        /// They consist of a 4 byte big endian length field, followed by the stated number of bytes representing the number in big endian format.
        /// </summary>
        public static BigInteger Decode(byte[] me,bool hasLength=true)
        {
            byte[] buffer;

            if(hasLength)
            {
                uint length=me.ReadUint32Be();
                buffer=new byte[length];

                Array.Copy(me,4,buffer,0,length);
            }
            else
            { buffer=me; }

            if(buffer.Length==0)
            { return BigInteger.Zero; }

            bool isNegative=(buffer[0] & 0x80)==0x80;
            if(isNegative)
            { buffer[0]&=0x7f; }

            BigInteger result=new BigInteger(buffer);
            return isNegative?result.Negate():result;
        }

		public BigInteger Add(
			BigInteger value)
		{
			if (this.sign == 0)
				return value;

			if (this.sign != value.sign)
			{
				if (value.sign == 0)
					return this;

				if (value.sign < 0)
					return Subtract(value.Negate());

				return value.Subtract(Negate());
			}

			return AddToMagnitude(value.magnitude);
		}

		public BigInteger Subtract(
			BigInteger n)
		{
			if (n.sign == 0)
				return this;

			if (this.sign == 0)
				return n.Negate();

			if (this.sign != n.sign)
				return Add(n.Negate());

			int compare = CompareNoLeadingZeroes(0, magnitude, 0, n.magnitude);
			if (compare == 0)
				return Zero;

			BigInteger bigun, lilun;
			if (compare < 0)
			{
				bigun = n;
				lilun = this;
			}
			else
			{
				bigun = this;
				lilun = n;
			}

			return new BigInteger(this.sign * compare, doSubBigLil(bigun.magnitude, lilun.magnitude), true);
		}

        public BigInteger ModPow(BigInteger e, BigInteger m)
        {
            if (m.sign < 1)
                throw new ArithmeticException("Modulus must be positive");

            if (m.Equals(One))
                return Zero;

            if (e.sign == 0)
                return One;

            if (sign == 0)
                return Zero;

            bool negExp = e.sign < 0;
            if (negExp)
                e = e.Negate();

            BigInteger result = this.Mod(m);
            if (!e.Equals(One))
            {
                if ((m.magnitude[m.magnitude.Length - 1] & 1) == 0)
                {
                    result = ModPowBarrett(result, e, m);
                }
                else
                {
                    result = ModPowMonty(result, e, m, true);
                }
            }

            if (negExp)
                result = result.ModInverse(m);

            return result;
        }

        public BigInteger Subtract(
			BigInteger value)
        {
            if (value.sign == 0)
                return this;

            if (this.sign == 0)
                return value.Negate();

            if (this.sign != value.sign)
                return Add(value.Negate());

            int compare = CompareTo(0, magnitude, 0, value.magnitude);
            if (compare == 0)
                return Zero;

            BigInteger bigun, lilun;
            if (compare < 0)
            {
                bigun = value;
                lilun = this;
            }
            else
            {
                bigun = this;
                lilun = value;
            }

            return new BigInteger(this.sign * compare, doSubBigLil(bigun.magnitude, lilun.magnitude), true);
        }

		public void TestTestBit()
		{
			for (int i = 0; i < 10; ++i)
			{
				BigInteger n = new BigInteger(128, random);

				Assert.IsFalse(n.TestBit(128));
				Assert.IsTrue(n.Negate().TestBit(128));

				for (int j = 0; j < 10; ++j)
				{
					int pos = random.Next(128);
					bool test = n.ShiftRight(pos).Remainder(two).Equals(one);

					Assert.AreEqual(test, n.TestBit(pos));
				}
			}
		}

		public void TestShiftLeft()
		{
			for (int i = 0; i < 100; ++i)
			{
				int shift = random.Next(128);

				BigInteger a = new BigInteger(128 + i, random).Add(one);
				int bits = a.BitCount; // Make sure nBits is set

				BigInteger negA = a.Negate();
				bits = negA.BitCount; // Make sure nBits is set

				BigInteger b = a.ShiftLeft(shift);
				BigInteger c = negA.ShiftLeft(shift);

				Assert.AreEqual(a.BitCount, b.BitCount);
				Assert.AreEqual(negA.BitCount + shift, c.BitCount);
				Assert.AreEqual(a.BitLength + shift, b.BitLength);
				Assert.AreEqual(negA.BitLength + shift, c.BitLength);

				int j = 0;
				for (; j < shift; ++j)
				{
					Assert.IsFalse(b.TestBit(j));
				}

				for (; j < b.BitLength; ++j)
				{
					Assert.AreEqual(a.TestBit(j - shift), b.TestBit(j));
				}
			}
		}

		public void TestMultiply()
		{
			BigInteger one = BigInteger.One;

			Assert.AreEqual(one, one.Negate().Multiply(one.Negate()));

			for (int i = 0; i < 100; ++i)
			{
				int aLen = 64 + random.Next(64);
				int bLen = 64 + random.Next(64);

				BigInteger a = new BigInteger(aLen, random).SetBit(aLen);
				BigInteger b = new BigInteger(bLen, random).SetBit(bLen);
				BigInteger c = new BigInteger(32, random);

				BigInteger ab = a.Multiply(b);
				BigInteger bc = b.Multiply(c);

				Assert.AreEqual(ab.Add(bc), a.Add(c).Multiply(b));
				Assert.AreEqual(ab.Subtract(bc), a.Subtract(c).Multiply(b));
			}

			// Special tests for power of two since uses different code path internally
			for (int i = 0; i < 100; ++i)
			{
				int shift = random.Next(64);
				BigInteger a = one.ShiftLeft(shift);
				BigInteger b = new BigInteger(64 + random.Next(64), random);
				BigInteger bShift = b.ShiftLeft(shift);

				Assert.AreEqual(bShift, a.Multiply(b));
				Assert.AreEqual(bShift.Negate(), a.Multiply(b.Negate()));
				Assert.AreEqual(bShift.Negate(), a.Negate().Multiply(b));
				Assert.AreEqual(bShift, a.Negate().Multiply(b.Negate()));

				Assert.AreEqual(bShift, b.Multiply(a));
				Assert.AreEqual(bShift.Negate(), b.Multiply(a.Negate()));
				Assert.AreEqual(bShift.Negate(), b.Negate().Multiply(a));
				Assert.AreEqual(bShift, b.Negate().Multiply(a.Negate()));
			}
		}

		public void TestDivideAndRemainder()
		{
			// TODO More basic tests

			BigInteger n = new BigInteger(48, random);
			BigInteger[] qr = n.DivideAndRemainder(one);
			Assert.AreEqual(n, qr[0]);
			Assert.AreEqual(zero, qr[1]);

			for (int rep = 0; rep < 10; ++rep)
			{
				BigInteger a = new BigInteger(100 - rep, 0, random);
				BigInteger b = new BigInteger(100 + rep, 0, random);
				BigInteger c = new BigInteger(10 + rep, 0, random);
				BigInteger d = a.Multiply(b).Add(c);
				BigInteger[] es = d.DivideAndRemainder(a);

				Assert.AreEqual(b, es[0]);
				Assert.AreEqual(c, es[1]);
			}

			// Special tests for power of two since uses different code path internally
			for (int i = 0; i < 100; ++i)
			{
				int shift = random.Next(64);
				BigInteger a = one.ShiftLeft(shift);
				BigInteger b = new BigInteger(64 + random.Next(64), random);
				BigInteger bShift = b.ShiftRight(shift);
				BigInteger bMod = b.And(a.Subtract(one));

				string data = "shift=" + shift +", b=" + b.ToString(16);

				qr = b.DivideAndRemainder(a);
				Assert.AreEqual(bShift, qr[0], data);
				Assert.AreEqual(bMod, qr[1], data);

				qr = b.DivideAndRemainder(a.Negate());
				Assert.AreEqual(bShift.Negate(), qr[0], data);
				Assert.AreEqual(bMod, qr[1], data);

				qr = b.Negate().DivideAndRemainder(a);
				Assert.AreEqual(bShift.Negate(), qr[0], data);
				Assert.AreEqual(bMod.Negate(), qr[1], data);

				qr = b.Negate().DivideAndRemainder(a.Negate());
				Assert.AreEqual(bShift, qr[0], data);
				Assert.AreEqual(bMod.Negate(), qr[1], data);
			}
		}

		public void TestDivide()
		{
			for (int i = -5; i <= 5; ++i)
			{
				try
				{
					val(i).Divide(zero);
					Assert.Fail("expected ArithmeticException");
				}
				catch (ArithmeticException) {}
			}

			int product = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9;
			int productPlus = product + 1;

			BigInteger bigProduct = val(product);
			BigInteger bigProductPlus = val(productPlus);

			for (int divisor = 1; divisor < 10; ++divisor)
			{
				// Exact division
				BigInteger expected = val(product / divisor);

				Assert.AreEqual(expected, bigProduct.Divide(val(divisor)));
				Assert.AreEqual(expected.Negate(), bigProduct.Negate().Divide(val(divisor)));
				Assert.AreEqual(expected.Negate(), bigProduct.Divide(val(divisor).Negate()));
				Assert.AreEqual(expected, bigProduct.Negate().Divide(val(divisor).Negate()));

				expected = val((product + 1)/divisor);

				Assert.AreEqual(expected, bigProductPlus.Divide(val(divisor)));
				Assert.AreEqual(expected.Negate(), bigProductPlus.Negate().Divide(val(divisor)));
				Assert.AreEqual(expected.Negate(), bigProductPlus.Divide(val(divisor).Negate()));
				Assert.AreEqual(expected, bigProductPlus.Negate().Divide(val(divisor).Negate()));
			}

			for (int rep = 0; rep < 10; ++rep)
			{
				BigInteger a = new BigInteger(100 - rep, 0, random);
				BigInteger b = new BigInteger(100 + rep, 0, random);
				BigInteger c = new BigInteger(10 + rep, 0, random);
				BigInteger d = a.Multiply(b).Add(c);
				BigInteger e = d.Divide(a);

				Assert.AreEqual(b, e);
			}

			// Special tests for power of two since uses different code path internally
			for (int i = 0; i < 100; ++i)
			{
				int shift = random.Next(64);
				BigInteger a = one.ShiftLeft(shift);
				BigInteger b = new BigInteger(64 + random.Next(64), random);
				BigInteger bShift = b.ShiftRight(shift);

				string data = "shift=" + shift +", b=" + b.ToString(16);

				Assert.AreEqual(bShift, b.Divide(a), data);
				Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data);
				Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data);
				Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data);
			}

			// Regression
			{
				int shift = 63;
				BigInteger a = one.ShiftLeft(shift);
				BigInteger b = new BigInteger(1, Hex.Decode("2504b470dc188499"));
				BigInteger bShift = b.ShiftRight(shift);

				string data = "shift=" + shift +", b=" + b.ToString(16);

				Assert.AreEqual(bShift, b.Divide(a), data);
				Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data);
//				Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data);
				Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data);
			}
		}

		public void TestBitLength()
		{
			Assert.AreEqual(0, zero.BitLength);
			Assert.AreEqual(1, one.BitLength);
			Assert.AreEqual(0, minusOne.BitLength);
			Assert.AreEqual(2, two.BitLength);
			Assert.AreEqual(1, minusTwo.BitLength);

			for (int i = 0; i < 100; ++i)
			{
				int bit = i + random.Next(64);
				BigInteger odd = new BigInteger(bit, random).SetBit(bit + 1).SetBit(0);
				BigInteger pow2 = one.ShiftLeft(bit);

				Assert.AreEqual(bit + 2, odd.BitLength);
				Assert.AreEqual(bit + 2, odd.Negate().BitLength);
				Assert.AreEqual(bit + 1, pow2.BitLength);
				Assert.AreEqual(bit, pow2.Negate().BitLength);
			}
		}