C# BigInteger.CompareTo方法代码示例

 private static void PortableDigitCount(BigInteger bi)
 {
     int kb=0;
     if(!bi.IsZero){
       while(true){
     if(bi.CompareTo((BigInteger)Int32.MaxValue)<=0) {
       int tmp = (int)bi;
       while (tmp > 0) {
         kb++;
         tmp /= 10;
       }
       kb=(kb == 0 ? 1 : kb);
       return kb;
     }
     BigInteger q=bi/(BigInteger)bidivisor;
     if(q.IsZero){
       int b=(int)bi;
       while(b>0){
         kb++;
         b/=10;
       }
       break;
     } else {
       kb+=4;
       bi=q;
     }
       }
     } else {
       kb=1;
     }
     return kb;
 }

        public static string ByteArrayToBase58(this byte[] ba)
        {
            byte[] tmp = ba;
            Array.Reverse(tmp);
            byte[] positiveBa;
            if (tmp[tmp.Length - 1] >= 0x80)
            {
                positiveBa = new byte[ba.Length + 1];
                Array.Copy(tmp, positiveBa, tmp.Length);
            }
            else positiveBa = tmp;

            BigInteger addrremain = new BigInteger(positiveBa);
            if (addrremain<0) throw new Exception("Negative? I wont positive");

            StringBuilder rv = new StringBuilder(100);

            while (addrremain.CompareTo(BigInteger.Zero) > 0)
            {
                var remainder = addrremain % 58;
                addrremain    = addrremain / 58;
                rv.Insert(0, B58[(int) remainder]);
            }

            // handle leading zeroes
            foreach (byte b in ba)
            {
                if (b != 0) break;
                rv = rv.Insert(0, '1');
            }
            string result = rv.ToString();
            return result;
        }

        public static string Encode(byte[] plaintext)
        {
            ContractsCommon.NotNull(plaintext, "plaintext");
            ContractsCommon.ResultIsNonNull<string>();

            var plaintextArr = new byte[plaintext.Length + 1];
            Array.Copy(plaintext, 0, plaintextArr, 1, plaintext.Length);
            Array.Reverse(plaintextArr);
            var workingValue = new BigInteger(plaintextArr);
            StringBuilder sb = new StringBuilder(plaintext.Length * 138 / 100 + 1);
            while (workingValue.CompareTo(BigInteger.Zero) > 0)
            {
                BigInteger remainder;
                workingValue = BigInteger.DivRem(workingValue, Base, out remainder);
                sb.Append(Alphabet[(int)remainder]);
            }
            Contract.Assert(workingValue.Sign >= 0);
            //sb.Insert(0, Alphabet[(int)workingValue]);

            for (int i = 0; i < plaintext.Length && plaintext[i] == 0; ++i)
            {
                sb.Append(Alphabet[0]);
            }

            var retVal = new char[sb.Length];
            sb.CopyTo(0, retVal, 0, sb.Length);
            Array.Reverse(retVal);
            return new string(retVal);
        }

        /**
         * An implementation of the RSASP method: Assuming that the designated
         * RSA private key is a valid one, this method computes a signature
         * representative for a designated message representative signed
         * by the holder of the designated RSA private key.
         * 
         * @param K the RSA private key.
         * @param m the message representative: an integer between
         *          0 and n - 1, where n
         *          is the RSA modulus.
         * @return the signature representative, an integer between
         *         0 and n - 1, where n
         *         is the RSA modulus.
         */
        public static BigInteger RSASP1(RSAKey K, BigInteger m)
        {
            // 1. If the representative c is not between 0 and n - 1, output
            // "representative out of range" and stop.
            BigInteger n = K.getModulus();
            if (m.CompareTo(BigInteger.Zero) < 0 || m.CompareTo(n - BigInteger.One) > 0)
                throw new ArgumentException();
            // 2. The representative m is computed as follows.
            BigInteger result;
            // a. If the first form (n, d) of K is used, let m = c^d mod n.
            BigInteger d = K.getExponent();
            result = BigInteger.ModPow(m, d, n);

            // 3. Output m
            return result;
        }

 public bool VerifySignature(byte[] message, BigInteger r, BigInteger s)
 {
     if (r.Sign < 1 || s.Sign < 1 || r.CompareTo(curve.N) >= 0 || s.CompareTo(curve.N) >= 0)
         return false;
     BigInteger e = CalculateE(curve.N, message);
     BigInteger c = s.ModInverse(curve.N);
     BigInteger u1 = (e * c).Mod(curve.N);
     BigInteger u2 = (r * c).Mod(curve.N);
     ECPoint point = SumOfTwoMultiplies(curve.G, u1, publicKey, u2);
     BigInteger v = point.X.Value.Mod(curve.N);
     return v.Equals(r);
 }

 public RSA()
 {
     r = new Random();
     List<int> primeP;
     List<int> primeQ;
     List<int> primeE;
     int Prandom = r.Next(200000);
     int Qrandom = r.Next(200000);
     int Erandom = r.Next(200000);
     primeP = GeneratePrimes(Prandom);
     primeQ = GeneratePrimes(Qrandom);
     primeE = GeneratePrimes(Erandom);
     p = primeP[primeP.Count-1];
     q = primeQ[primeQ.Count - 1];
     N = BigInteger.Multiply(p,q);
     phi =BigInteger.Multiply( BigInteger.Subtract(p,BigInteger.One),(BigInteger.Subtract(q,BigInteger.One)));
     e = primeE[primeE.Count - 1];
     while (BigInteger.GreatestCommonDivisor(phi, e).CompareTo(BigInteger.One) > 0 && e.CompareTo(phi) < 0)
     {
     BigInteger.Add(e, BigInteger.One);
     }
        // d = e.modInverse(phi);
     d= BigInteger.ModPow(1/e,1,phi);
 }

 private static void WritePortable(BigInteger bigint, Stream s)
 {
     if((s)==null)throw new ArgumentNullException("s");
       if((object)bigint==(object)null){
     s.WriteByte(0xf6);
     return;
       }
       int datatype=0;
       if(bigint.Sign<0){
     datatype=1;
     bigint+=(BigInteger)BigInteger.One;
     bigint=-(BigInteger)bigint;
       }
       if(bigint.CompareTo(Int64MaxValue)<=0){
     // If the big integer is representable as a long and in
     // major type 0 or 1, write that major type
     // instead of as a bignum
     long ui=(long)(BigInteger)bigint;
     WritePositiveInt64(datatype,ui,s);
       } else {
     using(MemoryStream ms=new MemoryStream()){
       long tmp=0;
       byte[] buffer=new byte[10];
       while(bigint.Sign>0){
     // To reduce the number of big integer
     // operations, extract the big int 56 bits at a time
     // (not 64, to avoid negative numbers)
     BigInteger tmpbigint=bigint&(BigInteger)FiftySixBitMask;
     tmp=(long)(BigInteger)tmpbigint;
     bigint>>=56;
     bool isNowZero=(bigint.IsZero);
     int bufferindex=0;
     for(int i=0;i<7 && (!isNowZero || tmp>0);i++){
       buffer[bufferindex]=(byte)(tmp&0xFF);
       tmp>>=8;
       bufferindex++;
     }
     ms.Write(buffer,0,bufferindex);
       }
       byte[] bytes=ms.ToArray();
       switch(bytes.Length){
     case 1: // Fits in 1 byte (won't normally happen though)
       buffer[0]=(byte)((datatype<<5)|24);
       buffer[1]=bytes[0];
       s.Write(buffer,0,2);
       break;
     case 2: // Fits in 2 bytes (won't normally happen though)
       buffer[0]=(byte)((datatype<<5)|25);
       buffer[1]=bytes[1];
       buffer[2]=bytes[0];
       s.Write(buffer,0,3);
       break;
     case 3:
     case 4:
       buffer[0]=(byte)((datatype<<5)|26);
       buffer[1]=(bytes.Length>3) ? bytes[3] : (byte)0;
       buffer[2]=bytes[2];
       buffer[3]=bytes[1];
       buffer[4]=bytes[0];
       s.Write(buffer,0,5);
       break;
     case 5:
     case 6:
     case 7:
     case 8:
       buffer[0]=(byte)((datatype<<5)|27);
       buffer[1]=(bytes.Length>7) ? bytes[7] : (byte)0;
       buffer[2]=(bytes.Length>6) ? bytes[6] : (byte)0;
       buffer[3]=(bytes.Length>5) ? bytes[5] : (byte)0;
       buffer[4]=bytes[4];
       buffer[5]=bytes[3];
       buffer[6]=bytes[2];
       buffer[7]=bytes[1];
       buffer[8]=bytes[0];
       s.Write(buffer,0,9);
       break;
     default:
       s.WriteByte((datatype==0) ?
                   (byte)0xC2 :
                   (byte)0xC3);
       WritePositiveInt(2,bytes.Length,s);
       for(int i=bytes.Length-1;i>=0;i--){
         s.WriteByte(bytes[i]);
       }
       break;
       }
     }
       }
 }

	    /**
	     * Raise a BigInteger to a BigInteger power.
	     *
	     * @param k Number to raise.
	     * @param e Exponent (must be positive or zero).
	     * @return k<sup>e</sup>
	     * @throws NotPositiveException if {@code e < 0}.
	     */
		//TODO: Implement this with an efficient algorithm which doesn't rely on the missing BigInteger functions
	    public static BigInteger pow(BigInteger k, BigInteger e) {
	        if (e.CompareTo(BigInteger.Zero) < 0) {
	            throw new NotPositiveException<BigInteger>(LocalizedFormats.EXPONENT, e);
	        }
	
	        BigInteger result = BigInteger.One;
	        //BigInteger k2p    = k;
			
			BigInteger incrementer = e;
			while(!BigInteger.Zero.Equals(incrementer)) {
				result = BigInteger.Multiply(result,k);
				incrementer = BigInteger.Subtract(incrementer,1);
			}

//	        while (!BigInteger.Zero.Equals(e)) {
//	            if (e.testBit(0)) {
//	                result = result.multiply(k2p);
//	            }
//	            k2p = k2p.multiply(k2p);
//	            e = e.shiftRight(1);
//	        }
	
	        return result;
	    }

		public void IComparable () {
			var a = new BigInteger (99);
			Assert.AreEqual (-1, a.CompareTo (100), "#1");
			Assert.AreEqual (1, a.CompareTo (null), "#2");
		}

		public void CompareLong () {
			long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 9999999, 100000000000L, 0xAA00000000, long.MaxValue, long.MinValue };

			for (int i = 0; i < values.Length; ++i) {
				for (int j = 0; j < values.Length; ++j) {
					var a = new BigInteger (values [i]);
					var b = values [j];
					var c = new BigInteger (b);
					
					Assert.AreEqual (a.CompareTo (c), a.CompareTo (b), "#a_" + i + "_" + j);

					Assert.AreEqual (a > c, a > b, "#b_" + i + "_" + j);
					Assert.AreEqual (a < c, a < b, "#c_" + i + "_" + j);
					Assert.AreEqual (a <= c, a <= b, "#d_" + i + "_" + j);
					Assert.AreEqual (a == c, a == b, "#e_" + i + "_" + j);
					Assert.AreEqual (a != c, a != b, "#f_" + i + "_" + j);
					Assert.AreEqual (a >= c, a >= b, "#g_" + i + "_" + j);

					Assert.AreEqual (c > a, b > a, "#ib_" + i + "_" + j);
					Assert.AreEqual (c < a, b < a, "#ic_" + i + "_" + j);
					Assert.AreEqual (c <= a, b <= a, "#id_" + i + "_" + j);
					Assert.AreEqual (c == a, b == a, "#ie_" + i + "_" + j);
					Assert.AreEqual (c != a, b != a, "#if_" + i + "_" + j);
					Assert.AreEqual (c >= a, b >= a, "#ig_" + i + "_" + j);
				}
			}
		}

		public void CompareOps2 () {
			BigInteger a = new BigInteger (100000000000L);
			BigInteger b = new BigInteger (28282828282UL);

			Assert.IsTrue (a >= b, "#1");
			Assert.IsTrue (a >= b, "#2");
			Assert.IsFalse (a < b, "#3");
			Assert.IsFalse (a <= b, "#4");
			Assert.AreEqual (1, a.CompareTo (b), "#5");
		}

		public void CompareOps () {
			long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
			for (int i = 0; i < values.Length; ++i) {
				for (int j = 0; j < values.Length; ++j) {
					var a = new BigInteger (values [i]);
					var b = new BigInteger (values [j]);
					
					Assert.AreEqual (values [i].CompareTo (values [j]), a.CompareTo (b), "#a_" + i + "_" + j);
					Assert.AreEqual (values [i].CompareTo (values [j]), BigInteger.Compare (a, b), "#b_" + i + "_" + j);

					Assert.AreEqual (values [i] < values [j], a < b, "#c_" + i + "_" + j);
					Assert.AreEqual (values [i] <= values [j], a <= b, "#d_" + i + "_" + j);
					Assert.AreEqual (values [i] == values [j], a == b, "#e_" + i + "_" + j);
					Assert.AreEqual (values [i] != values [j], a != b, "#f_" + i + "_" + j);
					Assert.AreEqual (values [i] >= values [j], a >= b, "#g_" + i + "_" + j);
					Assert.AreEqual (values [i] > values [j], a > b, "#h_" + i + "_" + j);
				}
			}
		}

 /// <summary>
 /// Осуществляет поиск простого числа, путём перебора всех числел, начиная с <code>value</code> до 
 /// <code>border</code> с шагом равным 2 по модулю.
 /// </summary>
 /// <param name="value">Начальное значение.</param>
 /// <param name="border">Граница интервала, в сторону которой будем двигатся.</param>
 /// <returns>Простое число, либо -1, если на заданном интервале нет простых чисел.</returns>
 private static BigInteger MoveToPrime(BigInteger value, BigInteger border, double probability)
 {
     int summand = (border >= value) ? 2 : -2;
     int compareResult = (summand > 0) ? -1 : 1;
     while (value.CompareTo(border) == compareResult)
     {
         value += summand;
         if (IsPrime(value, probability))
             return value;
     }
     return BigInteger.MinusOne;
 }

        // size is size in bits
        private BigInteger GenerateRandomLargePrime(BigInteger min, BigInteger max, uint size)
        {
            bool IsPrime = false;
            BigInteger p = new BigInteger();
            do
            {
                var rng = new RNGCryptoServiceProvider();
                byte[] bytes = new byte[size / 8];
                do
                {
                    rng.GetBytes(bytes);
                    p = new BigInteger(bytes);
                    if (p < 0)
                    {
                        p = BigInteger.Negate(p);
                    }
                }
                while (0 > p.CompareTo(min) || 0 < p.CompareTo(max));

                if (IsProbablePrime(p, 100))
                    IsPrime = true;
            } while (!IsPrime);

            return p;
        }

 /**
  * An implementation of the RSAVP method: Assuming that the designated
  * RSA public key is a valid one, this method computes a message
  * representative for the designated signature representative
  * generated by an RSA private key, for a message intended for the holder of
  * the designated RSA public key.
  * 
  * @param K the RSA public key.
  * @param s the signature representative, an integer between
  *          0 and n - 1, where n is the RSA modulus.
  * @return a message representative: an integer between 0
  *         and n - 1, where n is the RSA modulus.
  */
 public static BigInteger RSAVP1(RSAKey K, BigInteger s)
 {
     // 1. If the representative m is not between 0 and n - 1, output
     // "representative out of range" and stop.
     BigInteger n = K.getModulus();
     if (s.CompareTo(BigInteger.Zero) < 0 || s.CompareTo(n - BigInteger.One) > 0)
         throw new ArgumentException();
     // 2. Let c = m^e mod n.
     BigInteger e = K.getExponent();
     BigInteger result = BigInteger.ModPow(s, e, n); ;
     // 3. Output c.
     return result;
 }