diff --git a/crypto/src/math/BigInteger.cs b/crypto/src/math/BigInteger.cs
index 44d6ee20a..c8581775d 100644
--- a/crypto/src/math/BigInteger.cs
+++ b/crypto/src/math/BigInteger.cs
@@ -130,7 +130,7 @@ namespace Org.BouncyCastle.Math
private const long IMASK = 0xFFFFFFFFL;
private const ulong UIMASK = 0xFFFFFFFFUL;
- private static readonly int[] ZeroMagnitude = new int[0];
+ private static readonly uint[] ZeroMagnitude = new uint[0];
private static readonly byte[] ZeroEncoding = new byte[0];
private static readonly BigInteger[] SMALL_CONSTANTS = new BigInteger[17];
@@ -221,8 +221,8 @@ namespace Org.BouncyCastle.Math
}
}
- private int[] magnitude; // array of ints with [0] being the most significant
- private int sign; // -1 means -ve; +1 means +ve; 0 means 0;
+ private readonly uint[] magnitude; // array of uints with [0] being the most significant
+ private readonly int sign; // -1 means -ve; +1 means +ve; 0 means 0;
[NonSerialized]
private int nBits = -1; // cache BitCount() value
@@ -253,56 +253,49 @@ namespace Org.BouncyCastle.Math
return new BigInteger(sizeInBits, SecureRandom.ArbitraryRandom);
}
- private BigInteger(
- int signum,
- int[] mag,
- bool checkMag)
+ private BigInteger(int signum, uint[] mag, bool checkMag)
{
- if (checkMag)
+ if (!checkMag)
{
- int i = 0;
- while (i < mag.Length && mag[i] == 0)
- {
- ++i;
- }
+ this.sign = signum;
+ this.magnitude = mag;
+ return;
+ }
- if (i == mag.Length)
- {
- this.sign = 0;
- this.magnitude = ZeroMagnitude;
- }
- else
- {
- this.sign = signum;
+ int i = 0;
+ while (i < mag.Length && mag[i] == 0)
+ {
+ ++i;
+ }
- if (i == 0)
- {
- this.magnitude = mag;
- }
- else
- {
- // strip leading 0 words
- this.magnitude = new int[mag.Length - i];
- Array.Copy(mag, i, this.magnitude, 0, this.magnitude.Length);
- }
- }
+ if (i == mag.Length)
+ {
+ this.sign = 0;
+ this.magnitude = ZeroMagnitude;
}
else
{
this.sign = signum;
- this.magnitude = mag;
+
+ if (i == 0)
+ {
+ this.magnitude = mag;
+ }
+ else
+ {
+ // strip leading 0 words
+ this.magnitude = new uint[mag.Length - i];
+ Array.Copy(mag, i, this.magnitude, 0, this.magnitude.Length);
+ }
}
}
- public BigInteger(
- string value)
+ public BigInteger(string value)
: this(value, 10)
{
}
- public BigInteger(
- string str,
- int radix)
+ public BigInteger(string str, int radix)
{
if (str.Length == 0)
throw new FormatException("Zero length BigInteger");
@@ -314,36 +307,36 @@ namespace Org.BouncyCastle.Math
switch (radix)
{
- case 2:
- // Is there anyway to restrict to binary digits?
- style = NumberStyles.Integer;
- chunk = chunk2;
- r = radix2;
- rE = radix2E;
- break;
- case 8:
- // Is there anyway to restrict to octal digits?
- style = NumberStyles.Integer;
- chunk = chunk8;
- r = radix8;
- rE = radix8E;
- break;
- case 10:
- // This style seems to handle spaces and minus sign already (our processing redundant?)
- style = NumberStyles.Integer;
- chunk = chunk10;
- r = radix10;
- rE = radix10E;
- break;
- case 16:
- // TODO Should this be HexNumber?
- style = NumberStyles.AllowHexSpecifier;
- chunk = chunk16;
- r = radix16;
- rE = radix16E;
- break;
- default:
- throw new FormatException("Only bases 2, 8, 10, or 16 allowed");
+ case 2:
+ // Is there anyway to restrict to binary digits?
+ style = NumberStyles.Integer;
+ chunk = chunk2;
+ r = radix2;
+ rE = radix2E;
+ break;
+ case 8:
+ // Is there anyway to restrict to octal digits?
+ style = NumberStyles.Integer;
+ chunk = chunk8;
+ r = radix8;
+ rE = radix8E;
+ break;
+ case 10:
+ // This style seems to handle spaces and minus sign already (our processing redundant?)
+ style = NumberStyles.Integer;
+ chunk = chunk10;
+ r = radix10;
+ rE = radix10E;
+ break;
+ case 16:
+ // TODO Should this be HexNumber?
+ style = NumberStyles.AllowHexSpecifier;
+ chunk = chunk16;
+ r = radix16;
+ rE = radix16E;
+ break;
+ default:
+ throw new FormatException("Only bases 2, 8, 10, or 16 allowed");
}
@@ -394,28 +387,28 @@ namespace Org.BouncyCastle.Math
switch (radix)
{
- case 2:
- // TODO Need this because we are parsing in radix 10 above
- if (i >= 2)
- throw new FormatException("Bad character in radix 2 string: " + s);
-
- // TODO Parse 64 bits at a time
- b = b.ShiftLeft(1);
- break;
- case 8:
- // TODO Need this because we are parsing in radix 10 above
- if (i >= 8)
- throw new FormatException("Bad character in radix 8 string: " + s);
-
- // TODO Parse 63 bits at a time
- b = b.ShiftLeft(3);
- break;
- case 16:
- b = b.ShiftLeft(64);
- break;
- default:
- b = b.Multiply(rE);
- break;
+ case 2:
+ // TODO Need this because we are parsing in radix 10 above
+ if (i >= 2)
+ throw new FormatException("Bad character in radix 2 string: " + s);
+
+ // TODO Parse 64 bits at a time
+ b = b.ShiftLeft(1);
+ break;
+ case 8:
+ // TODO Need this because we are parsing in radix 10 above
+ if (i >= 8)
+ throw new FormatException("Bad character in radix 8 string: " + s);
+
+ // TODO Parse 63 bits at a time
+ b = b.ShiftLeft(3);
+ break;
+ case 16:
+ b = b.ShiftLeft(64);
+ break;
+ default:
+ b = b.Multiply(rE);
+ break;
}
b = b.Add(bi);
@@ -481,81 +474,75 @@ namespace Org.BouncyCastle.Math
magnitude = b.magnitude;
}
- public BigInteger(
- byte[] bytes)
+ public BigInteger(byte[] bytes)
: this(bytes, 0, bytes.Length)
{
}
- public BigInteger(
- byte[] bytes,
- int offset,
- int length)
+ public BigInteger(byte[] bytes, int offset, int length)
{
if (length == 0)
throw new FormatException("Zero length BigInteger");
// TODO Move this processing into MakeMagnitude (provide sign argument)
- if ((sbyte)bytes[offset] < 0)
+ if ((sbyte)bytes[offset] >= 0)
{
- this.sign = -1;
+ // strip leading zero bytes and return magnitude bytes
+ this.magnitude = MakeMagnitude(bytes, offset, length);
+ this.sign = this.magnitude.Length > 0 ? 1 : 0;
+ return;
+ }
- int end = offset + length;
+ this.sign = -1;
- int iBval;
- // strip leading sign bytes
- for (iBval = offset; iBval < end && ((sbyte)bytes[iBval] == -1); iBval++)
- {
- }
+ int end = offset + length;
- if (iBval >= end)
- {
- this.magnitude = One.magnitude;
- }
- else
- {
- int numBytes = end - iBval;
+ int iBval;
+ // strip leading sign bytes
+ for (iBval = offset; iBval < end && ((sbyte)bytes[iBval] == -1); iBval++)
+ {
+ }
+
+ if (iBval >= end)
+ {
+ this.magnitude = One.magnitude;
+ return;
+ }
+
+ int numBytes = end - iBval;
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
- Span<byte> inverse = numBytes <= 512
- ? stackalloc byte[numBytes]
- : new byte[numBytes];
+ Span<byte> inverse = numBytes <= 512
+ ? stackalloc byte[numBytes]
+ : new byte[numBytes];
#else
- byte[] inverse = new byte[numBytes];
+ byte[] inverse = new byte[numBytes];
#endif
- int index = 0;
- while (index < numBytes)
- {
- inverse[index++] = (byte)~bytes[iBval++];
- }
-
- Debug.Assert(iBval == end);
-
- while (inverse[--index] == byte.MaxValue)
- {
- inverse[index] = byte.MinValue;
- }
+ int index = 0;
+ while (index < numBytes)
+ {
+ inverse[index++] = (byte)~bytes[iBval++];
+ }
- inverse[index]++;
+ Debug.Assert(iBval == end);
- this.magnitude = MakeMagnitude(inverse);
- }
- }
- else
+ while (inverse[--index] == byte.MaxValue)
{
- // strip leading zero bytes and return magnitude bytes
- this.magnitude = MakeMagnitude(bytes, offset, length);
- this.sign = this.magnitude.Length > 0 ? 1 : 0;
+ inverse[index] = byte.MinValue;
}
+
+ inverse[index]++;
+
+ this.magnitude = MakeMagnitude(inverse);
}
- private static int[] MakeMagnitude(byte[] bytes)
+ private static uint[] MakeMagnitude(byte[] bytes)
{
return MakeMagnitude(bytes, 0, bytes.Length);
}
- private static int[] MakeMagnitude(byte[] bytes, int offset, int length)
+ private static uint[] MakeMagnitude(byte[] bytes, int offset, int length)
{
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
return MakeMagnitude(bytes.AsSpan(offset, length));
@@ -581,21 +568,21 @@ namespace Org.BouncyCastle.Math
if (nInts < 1)
return ZeroMagnitude;
- int[] mag = new int[nInts];
+ uint[] mag = new uint[nInts];
- int v = 0;
+ uint v = 0U;
int magnitudeIndex = 0;
for (int i = firstSignificant; i < end; ++i)
{
v <<= 8;
- v |= bytes[i] & 0xff;
+ v |= bytes[i];
bCount--;
if (bCount <= 0)
{
mag[magnitudeIndex] = v;
magnitudeIndex++;
bCount = BytesPerInt;
- v = 0;
+ v = 0U;
}
}
@@ -609,7 +596,7 @@ namespace Org.BouncyCastle.Math
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
- private static int[] MakeMagnitude(ReadOnlySpan<byte> bytes)
+ private static uint[] MakeMagnitude(ReadOnlySpan<byte> bytes)
{
int end = bytes.Length;
@@ -632,21 +619,21 @@ namespace Org.BouncyCastle.Math
if (nInts < 1)
return ZeroMagnitude;
- int[] mag = new int[nInts];
+ uint[] mag = new uint[nInts];
- int v = 0;
+ uint v = 0;
int magnitudeIndex = 0;
for (int i = firstSignificant; i < end; ++i)
{
v <<= 8;
- v |= bytes[i] & 0xff;
+ v |= bytes[i];
bCount--;
if (bCount <= 0)
{
mag[magnitudeIndex] = v;
magnitudeIndex++;
bCount = BytesPerInt;
- v = 0;
+ v = 0U;
}
}
@@ -702,9 +689,7 @@ namespace Org.BouncyCastle.Math
}
#endif
- public BigInteger(
- int sizeInBits,
- Random random)
+ public BigInteger(int sizeInBits, Random random)
{
if (sizeInBits < 0)
throw new ArgumentException("sizeInBits must be non-negative");
@@ -738,10 +723,7 @@ namespace Org.BouncyCastle.Math
this.sign = this.magnitude.Length < 1 ? 0 : 1;
}
- public BigInteger(
- int bitLength,
- int certainty,
- Random random)
+ public BigInteger(int bitLength, int certainty, Random random)
{
if (bitLength < 2)
throw new ArithmeticException("bitLength < 2");
@@ -795,7 +777,7 @@ namespace Org.BouncyCastle.Math
for (int j = 1; j < (magnitude.Length - 1); ++j)
{
- this.magnitude[j] ^= random.Next();
+ this.magnitude[j] ^= (uint)random.Next();
if (CheckProbablePrime(certainty, random, true))
return;
@@ -811,24 +793,22 @@ namespace Org.BouncyCastle.Math
/**
* return a = a + b - b preserved.
*/
- private static int[] AddMagnitudes(
- int[] a,
- int[] b)
+ private static uint[] AddMagnitudes(uint[] a, uint[] b)
{
int tI = a.Length - 1;
int vI = b.Length - 1;
- long m = 0;
+ ulong m = 0;
while (vI >= 0)
{
- m += ((long)(uint)a[tI] + (long)(uint)b[vI--]);
- a[tI--] = (int)m;
- m = (long)((ulong)m >> 32);
+ m += (ulong)a[tI] + b[vI--];
+ a[tI--] = (uint)m;
+ m >>= 32;
}
if (m != 0)
{
- while (tI >= 0 && ++a[tI--] == 0)
+ while (tI >= 0 && ++a[tI--] == uint.MinValue)
{
}
}
@@ -836,30 +816,26 @@ namespace Org.BouncyCastle.Math
return a;
}
- public BigInteger Add(
- BigInteger value)
+ public BigInteger Add(BigInteger value)
{
if (this.sign == 0)
return value;
- if (this.sign != value.sign)
- {
- if (value.sign == 0)
- return this;
+ if (this.sign == value.sign)
+ return AddToMagnitude(value.magnitude);
- if (value.sign < 0)
- return Subtract(value.Negate());
+ if (value.sign == 0)
+ return this;
- return value.Subtract(Negate());
- }
+ if (value.sign < 0)
+ return Subtract(value.Negate());
- return AddToMagnitude(value.magnitude);
+ return value.Subtract(Negate());
}
- private BigInteger AddToMagnitude(
- int[] magToAdd)
+ private BigInteger AddToMagnitude(uint[] magToAdd)
{
- int[] big, small;
+ uint[] big, small;
if (this.magnitude.Length < magToAdd.Length)
{
big = magToAdd;
@@ -874,19 +850,21 @@ namespace Org.BouncyCastle.Math
// Conservatively avoid over-allocation when no overflow possible
uint limit = uint.MaxValue;
if (big.Length == small.Length)
- limit -= (uint) small[0];
+ {
+ limit -= small[0];
+ }
- bool possibleOverflow = (uint) big[0] >= limit;
+ bool possibleOverflow = big[0] >= limit;
- int[] bigCopy;
+ uint[] bigCopy;
if (possibleOverflow)
{
- bigCopy = new int[big.Length + 1];
+ bigCopy = new uint[big.Length + 1];
big.CopyTo(bigCopy, 1);
}
else
{
- bigCopy = (int[]) big.Clone();
+ bigCopy = (uint[])big.Clone();
}
bigCopy = AddMagnitudes(bigCopy, small);
@@ -894,33 +872,25 @@ namespace Org.BouncyCastle.Math
return new BigInteger(this.sign, bigCopy, possibleOverflow);
}
- public BigInteger And(
- BigInteger value)
+ public BigInteger And(BigInteger value)
{
if (this.sign == 0 || value.sign == 0)
- {
return Zero;
- }
-
- int[] aMag = this.sign > 0
- ? this.magnitude
- : Add(One).magnitude;
- int[] bMag = value.sign > 0
- ? value.magnitude
- : value.Add(One).magnitude;
+ uint[] aMag = this.sign > 0 ? this.magnitude : Add(One).magnitude;
+ uint[] bMag = value.sign > 0 ? value.magnitude : value.Add(One).magnitude;
bool resultNeg = sign < 0 && value.sign < 0;
int resultLength = System.Math.Max(aMag.Length, bMag.Length);
- int[] resultMag = new int[resultLength];
+ uint[] resultMag = new uint[resultLength];
int aStart = resultMag.Length - aMag.Length;
int bStart = resultMag.Length - bMag.Length;
for (int i = 0; i < resultMag.Length; ++i)
{
- int aWord = i >= aStart ? aMag[i - aStart] : 0;
- int bWord = i >= bStart ? bMag[i - bStart] : 0;
+ uint aWord = i >= aStart ? aMag[i - aStart] : 0U;
+ uint bWord = i >= bStart ? bMag[i - bStart] : 0U;
if (this.sign < 0)
{
@@ -951,8 +921,7 @@ namespace Org.BouncyCastle.Math
return result;
}
- public BigInteger AndNot(
- BigInteger val)
+ public BigInteger AndNot(BigInteger val)
{
return And(val.Not());
}
@@ -983,12 +952,11 @@ namespace Org.BouncyCastle.Math
}
}
- public static int BitCnt(int i)
+ internal static int BitCnt(uint u)
{
#if NETCOREAPP3_0_OR_GREATER
- return BitOperations.PopCount((uint)i);
+ return BitOperations.PopCount(u);
#else
- uint u = (uint)i;
u = u - ((u >> 1) & 0x55555555);
u = (u & 0x33333333) + ((u >> 2) & 0x33333333);
u = (u + (u >> 4)) & 0x0f0f0f0f;
@@ -999,14 +967,14 @@ namespace Org.BouncyCastle.Math
#endif
}
- private static int CalcBitLength(int sign, int indx, int[] mag)
+ private static int CalcBitLength(int sign, int indx, uint[] mag)
{
for (;;)
{
if (indx >= mag.Length)
return 0;
- if (mag[indx] != 0)
+ if (mag[indx] != 0U)
break;
++indx;
@@ -1016,7 +984,7 @@ namespace Org.BouncyCastle.Math
int bitLength = 32 * ((mag.Length - indx) - 1);
// and determine bitlength of first int
- int firstMag = mag[indx];
+ uint firstMag = mag[indx];
bitLength += BitLen(firstMag);
// Check for negative powers of two
@@ -1030,7 +998,7 @@ namespace Org.BouncyCastle.Math
break;
}
}
- while (mag[indx] == 0);
+ while (mag[indx] == 0U);
}
return bitLength;
@@ -1060,12 +1028,11 @@ namespace Org.BouncyCastle.Math
#endif
}
- private static int BitLen(int w)
+ private static int BitLen(uint v)
{
#if NETCOREAPP3_0_OR_GREATER
- return 32 - BitOperations.LeadingZeroCount((uint)w);
+ return 32 - BitOperations.LeadingZeroCount(v);
#else
- uint v = (uint)w;
uint t = v >> 24;
if (t != 0)
return 24 + BitLengthTable[t];
@@ -1102,18 +1069,14 @@ namespace Org.BouncyCastle.Math
* unsigned comparison on two arrays - note the arrays may
* start with leading zeros.
*/
- private static int CompareTo(
- int xIndx,
- int[] x,
- int yIndx,
- int[] y)
+ private static int CompareTo(int xIndx, uint[] x, int yIndx, uint[] y)
{
- while (xIndx != x.Length && x[xIndx] == 0)
+ while (xIndx != x.Length && x[xIndx] == 0U)
{
xIndx++;
}
- while (yIndx != y.Length && y[yIndx] == 0)
+ while (yIndx != y.Length && y[yIndx] == 0U)
{
yIndx++;
}
@@ -1121,25 +1084,19 @@ namespace Org.BouncyCastle.Math
return CompareNoLeadingZeroes(xIndx, x, yIndx, y);
}
- private static int CompareNoLeadingZeroes(
- int xIndx,
- int[] x,
- int yIndx,
- int[] y)
+ private static int CompareNoLeadingZeroes(int xIndx, uint[] x, int yIndx, uint[] y)
{
int diff = (x.Length - y.Length) - (xIndx - yIndx);
if (diff != 0)
- {
return diff < 0 ? -1 : 1;
- }
// lengths of magnitudes the same, test the magnitude values
while (xIndx < x.Length)
{
- uint v1 = (uint)x[xIndx++];
- uint v2 = (uint)y[yIndx++];
+ uint v1 = x[xIndx++];
+ uint v2 = y[yIndx++];
if (v1 != v2)
return v1 < v2 ? -1 : 1;
@@ -1152,18 +1109,16 @@ namespace Org.BouncyCastle.Math
* return z = x / y - done in place (z value preserved, x contains the
* remainder)
*/
- private int[] Divide(
- int[] x,
- int[] y)
+ private uint[] Divide(uint[] x, uint[] y)
{
int xStart = 0;
- while (xStart < x.Length && x[xStart] == 0)
+ while (xStart < x.Length && x[xStart] == 0U)
{
++xStart;
}
int yStart = 0;
- while (yStart < y.Length && y[yStart] == 0)
+ while (yStart < y.Length && y[yStart] == 0U)
{
++yStart;
}
@@ -1171,7 +1126,7 @@ namespace Org.BouncyCastle.Math
Debug.Assert(yStart < y.Length);
int xyCmp = CompareNoLeadingZeroes(xStart, x, yStart, y);
- int[] count;
+ uint[] count;
if (xyCmp > 0)
{
@@ -1179,31 +1134,30 @@ namespace Org.BouncyCastle.Math
int xBitLength = CalcBitLength(1, xStart, x);
int shift = xBitLength - yBitLength;
- int[] iCount;
+ uint[] iCount;
int iCountStart = 0;
- int[] c;
+ uint[] c;
int cStart = 0;
int cBitLength = yBitLength;
if (shift > 0)
{
-// iCount = ShiftLeft(One.magnitude, shift);
- iCount = new int[(shift >> 5) + 1];
- iCount[0] = 1 << (shift % 32);
+ iCount = new uint[(shift >> 5) + 1];
+ iCount[0] = 1U << (shift % 32);
c = ShiftLeft(y, shift);
cBitLength += shift;
}
else
{
- iCount = new int[] { 1 };
+ iCount = new uint[1]{ 1U };
int len = y.Length - yStart;
- c = new int[len];
+ c = new uint[len];
Array.Copy(y, yStart, c, 0, len);
}
- count = new int[iCount.Length];
+ count = new uint[iCount.Length];
for (;;)
{
@@ -1213,13 +1167,12 @@ namespace Org.BouncyCastle.Math
Subtract(xStart, x, cStart, c);
AddMagnitudes(count, iCount);
- while (x[xStart] == 0)
+ while (x[xStart] == 0U)
{
if (++xStart == x.Length)
return count;
}
- //xBitLength = CalcBitLength(xStart, x);
xBitLength = 32 * (x.Length - xStart - 1) + BitLen(x[xStart]);
if (xBitLength <= yBitLength)
@@ -1239,10 +1192,12 @@ namespace Org.BouncyCastle.Math
// NB: The case where c[cStart] is 1-bit is harmless
if (shift == 1)
{
- uint firstC = (uint) c[cStart] >> 1;
- uint firstX = (uint) x[xStart];
+ uint firstC = c[cStart] >> 1;
+ uint firstX = x[xStart];
if (firstC > firstX)
+ {
++shift;
+ }
}
if (shift < 2)
@@ -1258,7 +1213,6 @@ namespace Org.BouncyCastle.Math
ShiftRightInPlace(iCountStart, iCount, shift);
}
- //cStart = c.Length - ((cBitLength + 31) / 32);
while (c[cStart] == 0)
{
++cStart;
@@ -1272,7 +1226,7 @@ namespace Org.BouncyCastle.Math
}
else
{
- count = new int[1];
+ count = new uint[1];
}
if (xyCmp == 0)
@@ -1284,8 +1238,7 @@ namespace Org.BouncyCastle.Math
return count;
}
- public BigInteger Divide(
- BigInteger val)
+ public BigInteger Divide(BigInteger val)
{
if (val.sign == 0)
throw new ArithmeticException("Division by zero error");
@@ -1299,13 +1252,12 @@ namespace Org.BouncyCastle.Math
return val.sign == this.sign ? result : result.Negate();
}
- int[] mag = (int[]) this.magnitude.Clone();
+ uint[] mag = (uint[])this.magnitude.Clone();
return new BigInteger(this.sign * val.sign, Divide(mag, val.magnitude), true);
}
- public BigInteger[] DivideAndRemainder(
- BigInteger val)
+ public BigInteger[] DivideAndRemainder(BigInteger val)
{
if (val.sign == 0)
throw new ArithmeticException("Division by zero error");
@@ -1321,15 +1273,15 @@ namespace Org.BouncyCastle.Math
{
int e = val.Abs().BitLength - 1;
BigInteger quotient = this.Abs().ShiftRight(e);
- int[] remainder = this.LastNBits(e);
+ uint[] remainder = this.LastNBits(e);
biggies[0] = val.sign == this.sign ? quotient : quotient.Negate();
biggies[1] = new BigInteger(this.sign, remainder, true);
}
else
{
- int[] remainder = (int[]) this.magnitude.Clone();
- int[] quotient = Divide(remainder, val.magnitude);
+ uint[] remainder = (uint[])this.magnitude.Clone();
+ uint[] quotient = Divide(remainder, val.magnitude);
biggies[0] = new BigInteger(this.sign * val.sign, quotient, true);
biggies[1] = new BigInteger(this.sign, remainder, true);
@@ -1360,7 +1312,6 @@ namespace Org.BouncyCastle.Math
private bool IsEqualMagnitude(BigInteger x)
{
- int[] xMag = x.magnitude;
if (magnitude.Length != x.magnitude.Length)
return false;
for (int i = 0; i < magnitude.Length; i++)
@@ -1371,8 +1322,7 @@ namespace Org.BouncyCastle.Math
return true;
}
- public BigInteger Gcd(
- BigInteger value)
+ public BigInteger Gcd(BigInteger value)
{
if (value.sign == 0)
return Abs();
@@ -1399,11 +1349,11 @@ namespace Org.BouncyCastle.Math
int hc = magnitude.Length;
if (magnitude.Length > 0)
{
- hc ^= magnitude[0];
+ hc ^= (int)magnitude[0];
if (magnitude.Length > 1)
{
- hc ^= magnitude[magnitude.Length - 1];
+ hc ^= (int)magnitude[magnitude.Length - 1];
}
}
@@ -1417,7 +1367,7 @@ namespace Org.BouncyCastle.Math
return One;
if (this.sign < 0)
- return new BigInteger(-1, doSubBigLil(this.magnitude, One.magnitude), true);
+ return new BigInteger(-1, DoSubBigLil(this.magnitude, One.magnitude), true);
return AddToMagnitude(One.magnitude);
}
@@ -1431,7 +1381,7 @@ namespace Org.BouncyCastle.Math
int n = magnitude.Length;
- int v = magnitude[n - 1];
+ int v = (int)magnitude[n - 1];
return sign < 0 ? -v : v;
}
@@ -1555,7 +1505,7 @@ namespace Org.BouncyCastle.Math
// let n = 1 + d . 2^s
BigInteger n = this;
- int s = n.GetLowestSetBitMaskFirst(-1 << 1);
+ int s = n.GetLowestSetBitMaskFirst(uint.MaxValue << 1);
Debug.Assert(s >= 1);
BigInteger r = n.ShiftRight(s);
@@ -1596,95 +1546,6 @@ namespace Org.BouncyCastle.Math
return true;
}
-// private bool SolovayStrassenTest(
-// int certainty,
-// Random random)
-// {
-// Debug.Assert(certainty > 0);
-// Debug.Assert(CompareTo(Two) > 0);
-// Debug.Assert(TestBit(0));
-//
-// BigInteger n = this;
-// BigInteger nMinusOne = n.Subtract(One);
-// BigInteger e = nMinusOne.ShiftRight(1);
-//
-// do
-// {
-// BigInteger a;
-// do
-// {
-// a = new BigInteger(nBitLength, random);
-// }
-// // NB: Spec says 0 < x < n, but 1 is trivial
-// while (a.CompareTo(One) <= 0 || a.CompareTo(n) >= 0);
-//
-//
-// // TODO Check this is redundant given the way Jacobi() works?
-//// if (!a.Gcd(n).Equals(One))
-//// return false;
-//
-// int x = Jacobi(a, n);
-//
-// if (x == 0)
-// return false;
-//
-// BigInteger check = a.ModPow(e, n);
-//
-// if (x == 1 && !check.Equals(One))
-// return false;
-//
-// if (x == -1 && !check.Equals(nMinusOne))
-// return false;
-//
-// --certainty;
-// }
-// while (certainty > 0);
-//
-// return true;
-// }
-//
-// private static int Jacobi(
-// BigInteger a,
-// BigInteger b)
-// {
-// Debug.Assert(a.sign >= 0);
-// Debug.Assert(b.sign > 0);
-// Debug.Assert(b.TestBit(0));
-// Debug.Assert(a.CompareTo(b) < 0);
-//
-// int totalS = 1;
-// for (;;)
-// {
-// if (a.sign == 0)
-// return 0;
-//
-// if (a.Equals(One))
-// break;
-//
-// int e = a.GetLowestSetBit();
-//
-// int bLsw = b.magnitude[b.magnitude.Length - 1];
-// if ((e & 1) != 0 && ((bLsw & 7) == 3 || (bLsw & 7) == 5))
-// totalS = -totalS;
-//
-// // TODO Confirm this is faster than later a1.Equals(One) test
-// if (a.BitLength == e + 1)
-// break;
-// BigInteger a1 = a.ShiftRight(e);
-//// if (a1.Equals(One))
-//// break;
-//
-// int a1Lsw = a1.magnitude[a1.magnitude.Length - 1];
-// if ((bLsw & 3) == 3 && (a1Lsw & 3) == 3)
-// totalS = -totalS;
-//
-//// a = b.Mod(a1);
-// a = b.Remainder(a1);
-// b = a1;
-// }
-// return totalS;
-// }
-
public long LongValue
{
get
@@ -1915,7 +1776,7 @@ namespace Org.BouncyCastle.Math
BigInteger result = this.Mod(m);
if (!e.Equals(One))
{
- if ((m.magnitude[m.magnitude.Length - 1] & 1) == 0)
+ if ((m.magnitude[m.magnitude.Length - 1] & 1U) == 0U)
{
result = ModPowBarrett(result, e, m);
}
@@ -2034,7 +1895,7 @@ namespace Org.BouncyCastle.Math
int n = m.magnitude.Length;
int powR = 32 * n;
bool smallMontyModulus = m.BitLength + 2 <= powR;
- uint mDash = (uint)m.GetMQuote();
+ uint mDash = m.GetMQuote();
// tmp = this * R mod m
if (convert)
@@ -2042,13 +1903,13 @@ namespace Org.BouncyCastle.Math
b = b.ShiftLeft(powR).Remainder(m);
}
- int[] yAccum = new int[n + 1];
+ uint[] yAccum = new uint[n + 1];
- int[] zVal = b.magnitude;
+ uint[] zVal = b.magnitude;
Debug.Assert(zVal.Length <= n);
if (zVal.Length < n)
{
- int[] tmp = new int[n];
+ uint[] tmp = new uint[n];
zVal.CopyTo(tmp, n - zVal.Length);
zVal = tmp;
}
@@ -2068,10 +1929,10 @@ namespace Org.BouncyCastle.Math
}
int numPowers = 1 << extraBits;
- int[][] oddPowers = new int[numPowers][];
+ uint[][] oddPowers = new uint[numPowers][];
oddPowers[0] = zVal;
- int[] zSquared = Arrays.Clone(zVal);
+ uint[] zSquared = Arrays.Clone(zVal);
SquareMonty(yAccum, zSquared, m.magnitude, mDash, smallMontyModulus);
for (int i = 1; i < numPowers; ++i)
@@ -2086,7 +1947,7 @@ namespace Org.BouncyCastle.Math
int window = windowList[0];
int mult = window & 0xFF, lastZeroes = window >> 8;
- int[] yVal;
+ uint[] yVal;
if (mult == 1)
{
yVal = zSquared;
@@ -2131,12 +1992,12 @@ namespace Org.BouncyCastle.Math
return new BigInteger(1, yVal, true);
}
- private static int[] GetWindowList(int[] mag, int extraBits)
+ private static int[] GetWindowList(uint[] mag, int extraBits)
{
- int v = mag[0];
+ int v = (int)mag[0];
Debug.Assert(v != 0);
- int leadingBits = BitLen(v);
+ int leadingBits = BitLen((uint)v);
int resultSize = (((mag.Length - 1) << 5) + leadingBits) / (1 + extraBits) + 2;
int[] result = new int[resultSize];
@@ -2149,7 +2010,7 @@ namespace Org.BouncyCastle.Math
int zeroes = 0;
int i = 0;
- for (; ; )
+ for (;;)
{
for (; bitPos < 32; ++bitPos)
{
@@ -2177,7 +2038,7 @@ namespace Org.BouncyCastle.Math
break;
}
- v = mag[i];
+ v = (int)mag[i];
bitPos = 0;
}
@@ -2207,9 +2068,7 @@ namespace Org.BouncyCastle.Math
/**
* return w with w = x * x - w is assumed to have enough space.
*/
- private static int[] Square(
- int[] w,
- int[] x)
+ private static uint[] Square(uint[] w, uint[] x)
{
// Note: this method allows w to be only (2 * x.Length - 1) words if result will fit
// if (w.Length != 2 * x.Length)
@@ -2221,27 +2080,27 @@ namespace Org.BouncyCastle.Math
for (int i = x.Length - 1; i > 0; --i)
{
- ulong v = (uint)x[i];
+ ulong v = x[i];
- c = v * v + (uint)w[wBase];
- w[wBase] = (int)c;
+ c = v * v + w[wBase];
+ w[wBase] = (uint)c;
c >>= 32;
for (int j = i - 1; j >= 0; --j)
{
- ulong prod = v * (uint)x[j];
+ ulong prod = v * x[j];
- c += ((uint)w[--wBase] & UIMASK) + ((uint)prod << 1);
- w[wBase] = (int)c;
+ c += (w[--wBase] & UIMASK) + ((uint)prod << 1);
+ w[wBase] = (uint)c;
c = (c >> 32) + (prod >> 31);
}
- c += (uint)w[--wBase];
- w[wBase] = (int)c;
+ c += w[--wBase];
+ w[wBase] = (uint)c;
if (--wBase >= 0)
{
- w[wBase] = (int)(c >> 32);
+ w[wBase] = (uint)(c >> 32);
}
else
{
@@ -2251,14 +2110,14 @@ namespace Org.BouncyCastle.Math
wBase += i;
}
- c = (uint)x[0];
+ c = x[0];
- c = c * c + (uint)w[wBase];
- w[wBase] = (int)c;
+ c = c * c + w[wBase];
+ w[wBase] = (uint)c;
if (--wBase >= 0)
{
- w[wBase] += (int)(c >> 32);
+ w[wBase] += (uint)(c >> 32);
}
else
{
@@ -2271,7 +2130,7 @@ namespace Org.BouncyCastle.Math
/**
* return x with x = y * z - x is assumed to have enough space.
*/
- private static int[] Multiply(int[] x, int[] y, int[] z)
+ private static uint[] Multiply(uint[] x, uint[] y, uint[] z)
{
int i = z.Length;
@@ -2290,9 +2149,9 @@ namespace Org.BouncyCastle.Math
for (int j = y.Length - 1; j >= 0; j--)
{
val += a * (y[j] & IMASK) + (x[xBase + j] & IMASK);
-
- x[xBase + j] = (int)val;
-
+
+ x[xBase + j] = (uint)val;
+
val = (long)((ulong)val >> 32);
}
}
@@ -2301,11 +2160,11 @@ namespace Org.BouncyCastle.Math
if (xBase >= 0)
{
- x[xBase] = (int)val;
+ x[xBase] = (uint)val;
}
else
{
- Debug.Assert(val == 0);
+ Debug.Assert(val == 0L);
}
}
while (i > 0);
@@ -2316,18 +2175,18 @@ namespace Org.BouncyCastle.Math
/**
* Calculate mQuote = -m^(-1) mod b with b = 2^32 (32 = word size)
*/
- private int GetMQuote()
+ private uint GetMQuote()
{
Debug.Assert(this.sign > 0);
- int d = -magnitude[magnitude.Length - 1];
+ uint d = 0U - magnitude[magnitude.Length - 1];
- Debug.Assert((d & 1) != 0);
+ Debug.Assert((d & 1U) != 0U);
- return (int)Raw.Mod.Inverse32((uint)d);
+ return Raw.Mod.Inverse32(d);
}
- private static void MontgomeryReduce(int[] x, int[] m, uint mDash) // mDash = -m^(-1) mod b
+ private static void MontgomeryReduce(uint[] x, uint[] m, uint mDash) // mDash = -m^(-1) mod b
{
// NOTE: Not a general purpose reduction (which would allow x up to twice the bitlength of m)
Debug.Assert(x.Length == m.Length);
@@ -2336,21 +2195,21 @@ namespace Org.BouncyCastle.Math
for (int i = n - 1; i >= 0; --i)
{
- uint x0 = (uint)x[n - 1];
+ uint x0 = x[n - 1];
ulong t = x0 * mDash;
- ulong carry = t * (uint)m[n - 1] + x0;
+ ulong carry = t * m[n - 1] + x0;
Debug.Assert((uint)carry == 0);
carry >>= 32;
for (int j = n - 2; j >= 0; --j)
{
- carry += t * (uint)m[j] + (uint)x[j];
- x[j + 1] = (int)carry;
+ carry += t * m[j] + x[j];
+ x[j + 1] = (uint)carry;
carry >>= 32;
}
- x[0] = (int)carry;
+ x[0] = (uint)carry;
Debug.Assert(carry >> 32 == 0);
}
@@ -2373,72 +2232,72 @@ namespace Org.BouncyCastle.Math
* <br/>
* NOTE: the indices of x, y, m, a different in HAC and in Java
*/
- private static void MultiplyMonty(int[] a, int[] x, int[] y, int[] m, uint mDash, bool smallMontyModulus)
+ private static void MultiplyMonty(uint[] a, uint[] x, uint[] y, uint[] m, uint mDash, bool smallMontyModulus)
// mDash = -m^(-1) mod b
{
int n = m.Length;
if (n == 1)
{
- x[0] = (int)MultiplyMontyNIsOne((uint)x[0], (uint)y[0], (uint)m[0], mDash);
+ x[0] = MultiplyMontyNIsOne(x[0], y[0], m[0], mDash);
return;
}
- uint y0 = (uint)y[n - 1];
- int aMax;
+ uint y0 = y[n - 1];
+ uint aMax;
{
- ulong xi = (uint)x[n - 1];
+ ulong xi = x[n - 1];
ulong carry = xi * y0;
ulong t = (uint)carry * mDash;
- ulong prod2 = t * (uint)m[n - 1];
+ ulong prod2 = t * m[n - 1];
carry += (uint)prod2;
Debug.Assert((uint)carry == 0);
carry = (carry >> 32) + (prod2 >> 32);
for (int j = n - 2; j >= 0; --j)
{
- ulong prod1 = xi * (uint)y[j];
- prod2 = t * (uint)m[j];
+ ulong prod1 = xi * y[j];
+ prod2 = t * m[j];
carry += (prod1 & UIMASK) + (uint)prod2;
- a[j + 2] = (int)carry;
+ a[j + 2] = (uint)carry;
carry = (carry >> 32) + (prod1 >> 32) + (prod2 >> 32);
}
- a[1] = (int)carry;
- aMax = (int)(carry >> 32);
+ a[1] = (uint)carry;
+ aMax = (uint)(carry >> 32);
}
for (int i = n - 2; i >= 0; --i)
{
- uint a0 = (uint)a[n];
- ulong xi = (uint)x[i];
+ uint a0 = a[n];
+ ulong xi = x[i];
ulong prod1 = xi * y0;
ulong carry = (prod1 & UIMASK) + a0;
ulong t = (uint)carry * mDash;
- ulong prod2 = t * (uint)m[n - 1];
+ ulong prod2 = t * m[n - 1];
carry += (uint)prod2;
Debug.Assert((uint)carry == 0);
carry = (carry >> 32) + (prod1 >> 32) + (prod2 >> 32);
for (int j = n - 2; j >= 0; --j)
{
- prod1 = xi * (uint)y[j];
- prod2 = t * (uint)m[j];
+ prod1 = xi * y[j];
+ prod2 = t * m[j];
- carry += (prod1 & UIMASK) + (uint)prod2 + (uint)a[j + 1];
- a[j + 2] = (int)carry;
+ carry += (prod1 & UIMASK) + (uint)prod2 + a[j + 1];
+ a[j + 2] = (uint)carry;
carry = (carry >> 32) + (prod1 >> 32) + (prod2 >> 32);
}
- carry += (uint)aMax;
- a[1] = (int)carry;
- aMax = (int)(carry >> 32);
+ carry += aMax;
+ a[1] = (uint)carry;
+ aMax = (uint)(carry >> 32);
}
a[0] = aMax;
@@ -2451,84 +2310,84 @@ namespace Org.BouncyCastle.Math
Array.Copy(a, 1, x, 0, n);
}
- private static void SquareMonty(int[] a, int[] x, int[] m, uint mDash, bool smallMontyModulus)
+ private static void SquareMonty(uint[] a, uint[] x, uint[] m, uint mDash, bool smallMontyModulus)
// mDash = -m^(-1) mod b
{
int n = m.Length;
if (n == 1)
{
- uint xVal = (uint)x[0];
- x[0] = (int)MultiplyMontyNIsOne(xVal, xVal, (uint)m[0], mDash);
+ uint xVal = x[0];
+ x[0] = MultiplyMontyNIsOne(xVal, xVal, m[0], mDash);
return;
}
- ulong x0 = (uint)x[n - 1];
- int aMax;
+ ulong x0 = x[n - 1];
+ uint aMax;
{
ulong carry = x0 * x0;
ulong t = (uint)carry * mDash;
- ulong prod2 = t * (uint)m[n - 1];
+ ulong prod2 = t * m[n - 1];
carry += (uint)prod2;
Debug.Assert((uint)carry == 0);
carry = (carry >> 32) + (prod2 >> 32);
for (int j = n - 2; j >= 0; --j)
{
- ulong prod1 = x0 * (uint)x[j];
- prod2 = t * (uint)m[j];
+ ulong prod1 = x0 * x[j];
+ prod2 = t * m[j];
carry += (prod2 & UIMASK) + ((uint)prod1 << 1);
- a[j + 2] = (int)carry;
+ a[j + 2] = (uint)carry;
carry = (carry >> 32) + (prod1 >> 31) + (prod2 >> 32);
}
- a[1] = (int)carry;
- aMax = (int)(carry >> 32);
+ a[1] = (uint)carry;
+ aMax = (uint)(carry >> 32);
}
for (int i = n - 2; i >= 0; --i)
{
- uint a0 = (uint)a[n];
+ uint a0 = a[n];
ulong t = a0 * mDash;
- ulong carry = t * (uint)m[n - 1] + a0;
+ ulong carry = t * m[n - 1] + a0;
Debug.Assert((uint)carry == 0);
carry >>= 32;
for (int j = n - 2; j > i; --j)
{
- carry += t * (uint)m[j] + (uint)a[j + 1];
- a[j + 2] = (int)carry;
+ carry += t * m[j] + a[j + 1];
+ a[j + 2] = (uint)carry;
carry >>= 32;
}
- ulong xi = (uint)x[i];
+ ulong xi = x[i];
{
ulong prod1 = xi * xi;
- ulong prod2 = t * (uint)m[i];
+ ulong prod2 = t * m[i];
- carry += (prod1 & UIMASK) + (uint)prod2 + (uint)a[i + 1];
- a[i + 2] = (int)carry;
+ carry += (prod1 & UIMASK) + (uint)prod2 + a[i + 1];
+ a[i + 2] = (uint)carry;
carry = (carry >> 32) + (prod1 >> 32) + (prod2 >> 32);
}
for (int j = i - 1; j >= 0; --j)
{
- ulong prod1 = xi * (uint)x[j];
- ulong prod2 = t * (uint)m[j];
+ ulong prod1 = xi * x[j];
+ ulong prod2 = t * m[j];
- carry += (prod2 & UIMASK) + ((uint)prod1 << 1) + (uint)a[j + 1];
- a[j + 2] = (int)carry;
+ carry += (prod2 & UIMASK) + ((uint)prod1 << 1) + a[j + 1];
+ a[j + 2] = (uint)carry;
carry = (carry >> 32) + (prod1 >> 31) + (prod2 >> 32);
}
- carry += (uint)aMax;
- a[1] = (int)carry;
- aMax = (int)(carry >> 32);
+ carry += aMax;
+ a[1] = (uint)carry;
+ aMax = (uint)(carry >> 32);
}
a[0] = aMax;
@@ -2558,8 +2417,7 @@ namespace Org.BouncyCastle.Math
return (uint)carry;
}
- public BigInteger Multiply(
- BigInteger val)
+ public BigInteger Multiply(BigInteger val)
{
if (val == this)
return Square();
@@ -2580,7 +2438,7 @@ namespace Org.BouncyCastle.Math
}
int resLength = magnitude.Length + val.magnitude.Length;
- int[] res = new int[resLength];
+ uint[] res = new uint[resLength];
Multiply(res, this.magnitude, val.magnitude);
@@ -2595,9 +2453,11 @@ namespace Org.BouncyCastle.Math
if (this.QuickPow2Check())
return ShiftLeft(Abs().BitLength - 1);
int resLength = magnitude.Length << 1;
- if ((uint)magnitude[0] >> 16 == 0)
+ if (magnitude[0] >> 16 == 0U)
+ {
--resLength;
- int[] res = new int[resLength];
+ }
+ uint[] res = new uint[resLength];
Square(res, magnitude);
return new BigInteger(1, res, false);
}
@@ -2675,43 +2535,38 @@ namespace Org.BouncyCastle.Math
return y;
}
- public static BigInteger ProbablePrime(
- int bitLength,
- Random random)
+ public static BigInteger ProbablePrime(int bitLength, Random random)
{
return new BigInteger(bitLength, 100, random);
}
- private int Remainder(
- int m)
+ private int Remainder(int m)
{
Debug.Assert(m > 0);
long acc = 0;
for (int pos = 0; pos < magnitude.Length; ++pos)
{
- long posVal = (uint) magnitude[pos];
+ long posVal = magnitude[pos];
acc = (acc << 32 | posVal) % m;
}
- return (int) acc;
+ return (int)acc;
}
/**
* return x = x % y - done in place (y value preserved)
*/
- private static int[] Remainder(
- int[] x,
- int[] y)
+ private static uint[] Remainder(uint[] x, uint[] y)
{
int xStart = 0;
- while (xStart < x.Length && x[xStart] == 0)
+ while (xStart < x.Length && x[xStart] == 0U)
{
++xStart;
}
int yStart = 0;
- while (yStart < y.Length && y[yStart] == 0)
+ while (yStart < y.Length && y[yStart] == 0U)
{
++yStart;
}
@@ -2726,19 +2581,19 @@ namespace Org.BouncyCastle.Math
int xBitLength = CalcBitLength(1, xStart, x);
int shift = xBitLength - yBitLength;
- int[] c;
+ uint[] c;
int cStart = 0;
int cBitLength = yBitLength;
if (shift > 0)
{
c = ShiftLeft(y, shift);
cBitLength += shift;
- Debug.Assert(c[0] != 0);
+ Debug.Assert(c[0] != 0U);
}
else
{
int len = y.Length - yStart;
- c = new int[len];
+ c = new uint[len];
Array.Copy(y, yStart, c, 0, len);
}
@@ -2749,13 +2604,12 @@ namespace Org.BouncyCastle.Math
{
Subtract(xStart, x, cStart, c);
- while (x[xStart] == 0)
+ while (x[xStart] == 0U)
{
if (++xStart == x.Length)
return x;
}
- //xBitLength = CalcBitLength(xStart, x);
xBitLength = 32 * (x.Length - xStart - 1) + BitLen(x[xStart]);
if (xBitLength <= yBitLength)
@@ -2775,10 +2629,12 @@ namespace Org.BouncyCastle.Math
// NB: The case where c[cStart] is 1-bit is harmless
if (shift == 1)
{
- uint firstC = (uint) c[cStart] >> 1;
- uint firstX = (uint) x[xStart];
+ uint firstC = c[cStart] >> 1;
+ uint firstX = x[xStart];
if (firstC > firstX)
+ {
++shift;
+ }
}
if (shift < 2)
@@ -2792,8 +2648,7 @@ namespace Org.BouncyCastle.Math
cBitLength -= shift;
}
- //cStart = c.Length - ((cBitLength + 31) / 32);
- while (c[cStart] == 0)
+ while (c[cStart] == 0U)
{
++cStart;
}
@@ -2808,8 +2663,7 @@ namespace Org.BouncyCastle.Math
return x;
}
- public BigInteger Remainder(
- BigInteger n)
+ public BigInteger Remainder(BigInteger n)
{
if (n.sign == 0)
throw new ArithmeticException("Division by zero error");
@@ -2820,7 +2674,7 @@ namespace Org.BouncyCastle.Math
// For small values, use fast remainder method
if (n.magnitude.Length == 1)
{
- int val = n.magnitude[0];
+ int val = (int)n.magnitude[0];
if (val > 0)
{
@@ -2832,14 +2686,14 @@ namespace Org.BouncyCastle.Math
return rem == 0
? Zero
- : new BigInteger(sign, new int[]{ rem }, false);
+ : new BigInteger(sign, new uint[1]{ (uint)rem }, false);
}
}
if (CompareNoLeadingZeroes(0, magnitude, 0, n.magnitude) < 0)
return this;
- int[] result;
+ uint[] result;
if (n.QuickPow2Check()) // n is power of two
{
// TODO Move before small values branch above?
@@ -2847,29 +2701,28 @@ namespace Org.BouncyCastle.Math
}
else
{
- result = (int[]) this.magnitude.Clone();
+ result = (uint[])this.magnitude.Clone();
result = Remainder(result, n.magnitude);
}
return new BigInteger(sign, result, true);
}
- private int[] LastNBits(
- int n)
+ private uint[] LastNBits(int n)
{
if (n < 1)
return ZeroMagnitude;
int numWords = (n + BitsPerInt - 1) / BitsPerInt;
numWords = System.Math.Min(numWords, this.magnitude.Length);
- int[] result = new int[numWords];
+ uint[] result = new uint[numWords];
Array.Copy(this.magnitude, this.magnitude.Length - numWords, result, 0, numWords);
int excessBits = (numWords << 5) - n;
if (excessBits > 0)
{
- result[0] &= (int)(uint.MaxValue >> excessBits);
+ result[0] &= uint.MaxValue >> excessBits;
}
return result;
@@ -2881,7 +2734,7 @@ namespace Org.BouncyCastle.Math
int n = magnitude.Length;
if (w >= n)
return Zero;
- int[] mag = new int[n - w];
+ uint[] mag = new uint[n - w];
Array.Copy(magnitude, 0, mag, 0, n - w);
return new BigInteger(sign, mag, false);
}
@@ -2892,7 +2745,7 @@ namespace Org.BouncyCastle.Math
int n = magnitude.Length;
if (w >= n)
return this;
- int[] mag = new int[w];
+ uint[] mag = new uint[w];
Array.Copy(magnitude, n - w, mag, 0, w);
return new BigInteger(sign, mag, false);
}
@@ -2900,42 +2753,40 @@ namespace Org.BouncyCastle.Math
/**
* do a left shift - this returns a new array.
*/
- private static int[] ShiftLeft(
- int[] mag,
- int n)
+ private static uint[] ShiftLeft(uint[] mag, int n)
{
int nInts = (int)((uint)n >> 5);
int nBits = n & 0x1f;
int magLen = mag.Length;
- int[] newMag;
+ uint[] newMag;
if (nBits == 0)
{
- newMag = new int[magLen + nInts];
+ newMag = new uint[magLen + nInts];
mag.CopyTo(newMag, 0);
}
else
{
int i = 0;
int nBits2 = 32 - nBits;
- int highBits = (int)((uint)mag[0] >> nBits2);
+ uint highBits = mag[0] >> nBits2;
- if (highBits != 0)
+ if (highBits != 0U)
{
- newMag = new int[magLen + nInts + 1];
+ newMag = new uint[magLen + nInts + 1];
newMag[i++] = highBits;
}
else
{
- newMag = new int[magLen + nInts];
+ newMag = new uint[magLen + nInts];
}
- int m = mag[0];
+ uint m = mag[0];
for (int j = 0; j < magLen - 1; j++)
{
- int next = mag[j + 1];
+ uint next = mag[j + 1];
- newMag[i++] = (m << nBits) | (int)((uint)next >> nBits2);
+ newMag[i++] = (m << nBits) | (next >> nBits2);
m = next;
}
@@ -2958,8 +2809,7 @@ namespace Org.BouncyCastle.Math
return carry;
}
- public BigInteger ShiftLeft(
- int n)
+ public BigInteger ShiftLeft(int n)
{
if (sign == 0 || magnitude.Length == 0)
return Zero;
@@ -2990,10 +2840,7 @@ namespace Org.BouncyCastle.Math
/**
* do a right shift - this does it in place.
*/
- private static void ShiftRightInPlace(
- int start,
- int[] mag,
- int n)
+ private static void ShiftRightInPlace(int start, uint[] mag, int n)
{
int nInts = (int)((uint)n >> 5) + start;
int nBits = n & 0x1f;
@@ -3009,49 +2856,46 @@ namespace Org.BouncyCastle.Math
}
for (int i = nInts - 1; i >= start; i--)
{
- mag[i] = 0;
+ mag[i] = 0U;
}
}
if (nBits != 0)
{
int nBits2 = 32 - nBits;
- int m = mag[magEnd];
+ uint m = mag[magEnd];
for (int i = magEnd; i > nInts; --i)
{
- int next = mag[i - 1];
+ uint next = mag[i - 1];
- mag[i] = (int)((uint)m >> nBits) | (next << nBits2);
+ mag[i] = (m >> nBits) | (next << nBits2);
m = next;
}
- mag[nInts] = (int)((uint)mag[nInts] >> nBits);
+ mag[nInts] = mag[nInts] >> nBits;
}
}
/**
* do a right shift by one - this does it in place.
*/
- private static void ShiftRightOneInPlace(
- int start,
- int[] mag)
+ private static void ShiftRightOneInPlace(int start, uint[] mag)
{
int i = mag.Length;
- int m = mag[i - 1];
+ uint m = mag[i - 1];
while (--i > start)
{
- int next = mag[i - 1];
- mag[i] = ((int)((uint)m >> 1)) | (next << 31);
+ uint next = mag[i - 1];
+ mag[i] = (m >> 1) | (next << 31);
m = next;
}
- mag[start] = (int)((uint)mag[start] >> 1);
+ mag[start] = mag[start] >> 1;
}
- public BigInteger ShiftRight(
- int n)
+ public BigInteger ShiftRight(int n)
{
if (n == 0)
return this;
@@ -3062,14 +2906,8 @@ namespace Org.BouncyCastle.Math
if (n >= BitLength)
return (this.sign < 0 ? One.Negate() : Zero);
-// int[] res = (int[]) this.magnitude.Clone();
-//
-// ShiftRightInPlace(0, res, n);
-//
-// return new BigInteger(this.sign, res, true);
-
int resultLength = (BitLength - n + 31) >> 5;
- int[] res = new int[resultLength];
+ uint[] res = new uint[resultLength];
int numInts = n >> 5;
int numBits = n & 31;
@@ -3085,7 +2923,7 @@ namespace Org.BouncyCastle.Math
int magPos = this.magnitude.Length - 1 - numInts;
for (int i = resultLength - 1; i >= 0; --i)
{
- res[i] = (int)((uint) this.magnitude[magPos--] >> numBits);
+ res[i] = this.magnitude[magPos--] >> numBits;
if (magPos >= 0)
{
@@ -3094,7 +2932,7 @@ namespace Org.BouncyCastle.Math
}
}
- Debug.Assert(res[0] != 0);
+ Debug.Assert(res[0] != 0U);
return new BigInteger(this.sign, res, false);
}
@@ -3107,11 +2945,7 @@ namespace Org.BouncyCastle.Math
/**
* returns x = x - y - we assume x is >= y
*/
- private static int[] Subtract(
- int xStart,
- int[] x,
- int yStart,
- int[] y)
+ private static uint[] Subtract(int xStart, uint[] x, int yStart, uint[] y)
{
Debug.Assert(yStart < y.Length);
Debug.Assert(x.Length - xStart >= y.Length - yStart);
@@ -3124,16 +2958,15 @@ namespace Org.BouncyCastle.Math
do
{
m = (x[--iT] & IMASK) - (y[--iV] & IMASK) + borrow;
- x[iT] = (int) m;
+ x[iT] = (uint)m;
-// borrow = (m < 0) ? -1 : 0;
borrow = (int)(m >> 63);
}
while (iV > yStart);
if (borrow != 0)
{
- while (--x[--iT] == -1)
+ while (--x[--iT] == uint.MaxValue)
{
}
}
@@ -3141,8 +2974,7 @@ namespace Org.BouncyCastle.Math
return x;
}
- public BigInteger Subtract(
- BigInteger n)
+ public BigInteger Subtract(BigInteger n)
{
if (n.sign == 0)
return this;
@@ -3169,14 +3001,12 @@ namespace Org.BouncyCastle.Math
lilun = n;
}
- return new BigInteger(this.sign * compare, doSubBigLil(bigun.magnitude, lilun.magnitude), true);
+ return new BigInteger(this.sign * compare, DoSubBigLil(bigun.magnitude, lilun.magnitude), true);
}
- private static int[] doSubBigLil(
- int[] bigMag,
- int[] lilMag)
+ private static uint[] DoSubBigLil(uint[] bigMag, uint[] lilMag)
{
- int[] res = (int[]) bigMag.Clone();
+ uint[] res = (uint[])bigMag.Clone();
return Subtract(0, res, 0, lilMag);
}
@@ -3270,12 +3100,12 @@ namespace Org.BouncyCastle.Math
{
while (magIndex > 1)
{
- uint mag = (uint) magnitude[--magIndex];
+ uint mag = magnitude[--magIndex];
bytesIndex -= 4;
Pack.UInt32_To_BE(mag, bytes, bytesIndex);
}
- uint lastMag = (uint) magnitude[0];
+ uint lastMag = magnitude[0];
while (lastMag > byte.MaxValue)
{
bytes[--bytesIndex] = (byte) lastMag;
@@ -3295,7 +3125,7 @@ namespace Org.BouncyCastle.Math
while (magIndex > 1)
{
- uint mag = ~((uint) magnitude[--magIndex]);
+ uint mag = ~magnitude[--magIndex];
if (carry)
{
@@ -3306,7 +3136,7 @@ namespace Org.BouncyCastle.Math
Pack.UInt32_To_BE(mag, bytes, bytesIndex);
}
- uint lastMag = (uint) magnitude[0];
+ uint lastMag = magnitude[0];
if (carry)
{
@@ -3316,11 +3146,11 @@ namespace Org.BouncyCastle.Math
while (lastMag > byte.MaxValue)
{
- bytes[--bytesIndex] = (byte) ~lastMag;
+ bytes[--bytesIndex] = (byte)~lastMag;
lastMag >>= 8;
}
- bytes[--bytesIndex] = (byte) ~lastMag;
+ bytes[--bytesIndex] = (byte)~lastMag;
Debug.Assert((bytesIndex & 1) == bytesIndex);
if (bytesIndex != 0)
{
@@ -3356,12 +3186,12 @@ namespace Org.BouncyCastle.Math
{
while (magIndex > 1)
{
- uint mag = (uint) magnitude[--magIndex];
+ uint mag = magnitude[--magIndex];
bytesIndex -= 4;
Pack.UInt32_To_BE(mag, output[bytesIndex..]);
}
- uint lastMag = (uint)magnitude[0];
+ uint lastMag = magnitude[0];
while (lastMag > byte.MaxValue)
{
output[--bytesIndex] = (byte)lastMag;
@@ -3381,7 +3211,7 @@ namespace Org.BouncyCastle.Math
while (magIndex > 1)
{
- uint mag = ~((uint)magnitude[--magIndex]);
+ uint mag = ~magnitude[--magIndex];
if (carry)
{
@@ -3392,7 +3222,7 @@ namespace Org.BouncyCastle.Math
Pack.UInt32_To_BE(mag, output[bytesIndex..]);
}
- uint lastMag = (uint)magnitude[0];
+ uint lastMag = magnitude[0];
if (carry)
{
@@ -3439,7 +3269,7 @@ namespace Org.BouncyCastle.Math
{
while (magIndex > 0)
{
- output[--intsIndex] = (uint)magnitude[--magIndex];
+ output[--intsIndex] = magnitude[--magIndex];
}
Debug.Assert((intsIndex & 1) == intsIndex);
@@ -3453,7 +3283,7 @@ namespace Org.BouncyCastle.Math
ulong cc = 1UL;
while (magIndex > 0)
{
- cc += ~(uint)magnitude[--magIndex];
+ cc += ~magnitude[--magIndex];
output[--intsIndex] = (uint)cc; cc >>= 32;
}
Debug.Assert(cc == 0UL);
@@ -3489,7 +3319,7 @@ namespace Org.BouncyCastle.Math
{
for (int intsIndex = 0; intsIndex < magnitude.Length; ++intsIndex)
{
- output[intsIndex] = (uint)magnitude[--magIndex];
+ output[intsIndex] = magnitude[--magIndex];
}
if (nInts > magnitude.Length)
@@ -3503,7 +3333,7 @@ namespace Org.BouncyCastle.Math
ulong cc = 1UL;
for (int intsIndex = 0; intsIndex < magnitude.Length; ++intsIndex)
{
- cc += ~(uint)magnitude[--magIndex];
+ cc += ~magnitude[--magIndex];
output[intsIndex] = (uint)cc; cc >>= 32;
}
Debug.Assert(cc == 0UL);
@@ -3528,13 +3358,13 @@ namespace Org.BouncyCastle.Math
switch (radix)
{
- case 2:
- case 8:
- case 10:
- case 16:
- break;
- default:
- throw new FormatException("Only bases 2, 8, 10, 16 are allowed");
+ case 2:
+ case 8:
+ case 10:
+ case 16:
+ break;
+ default:
+ throw new FormatException("Only bases 2, 8, 10, 16 are allowed");
}
// NB: Can only happen to internally managed instances
@@ -3549,18 +3379,14 @@ namespace Org.BouncyCastle.Math
int firstNonZero = 0;
while (firstNonZero < magnitude.Length)
{
- if (magnitude[firstNonZero] != 0)
- {
+ if (magnitude[firstNonZero] != 0U)
break;
- }
+
++firstNonZero;
}
if (firstNonZero == magnitude.Length)
- {
return "0";
- }
-
StringBuilder sb = new StringBuilder();
if (sign == -1)
@@ -3672,18 +3498,17 @@ namespace Org.BouncyCastle.Math
sb.Append(s);
}
- private static BigInteger CreateUValueOf(
- ulong value)
+ private static BigInteger CreateUValueOf(ulong value)
{
- int msw = (int)(value >> 32);
- int lsw = (int)value;
+ uint msw = (uint)(value >> 32);
+ uint lsw = (uint)value;
if (msw != 0)
- return new BigInteger(1, new int[] { msw, lsw }, false);
+ return new BigInteger(1, new uint[]{ msw, lsw }, false);
if (lsw != 0)
{
- BigInteger n = new BigInteger(1, new int[] { lsw }, false);
+ BigInteger n = new BigInteger(1, new uint[]{ lsw }, false);
// Check for a power of two
if ((lsw & -lsw) == lsw)
{
@@ -3695,8 +3520,7 @@ namespace Org.BouncyCastle.Math
return Zero;
}
- private static BigInteger CreateValueOf(
- long value)
+ private static BigInteger CreateValueOf(long value)
{
if (value < 0)
{
@@ -3709,13 +3533,10 @@ namespace Org.BouncyCastle.Math
return CreateUValueOf((ulong)value);
}
- public static BigInteger ValueOf(
- long value)
+ public static BigInteger ValueOf(long value)
{
if (value >= 0 && value < SMALL_CONSTANTS.Length)
- {
return SMALL_CONSTANTS[value];
- }
return CreateValueOf(value);
}
@@ -3725,19 +3546,19 @@ namespace Org.BouncyCastle.Math
if (this.sign == 0)
return -1;
- return GetLowestSetBitMaskFirst(-1);
+ return GetLowestSetBitMaskFirst(uint.MaxValue);
}
- private int GetLowestSetBitMaskFirst(int firstWordMask)
+ private int GetLowestSetBitMaskFirst(uint firstWordMaskX)
{
int w = magnitude.Length, offset = 0;
- uint word = (uint)(magnitude[--w] & firstWordMask);
- Debug.Assert(magnitude[0] != 0);
+ uint word = magnitude[--w] & firstWordMaskX;
+ Debug.Assert(magnitude[0] != 0U);
while (word == 0)
{
- word = (uint)magnitude[--w];
+ word = magnitude[--w];
offset += 32;
}
@@ -3760,8 +3581,7 @@ namespace Org.BouncyCastle.Math
return offset;
}
- public bool TestBit(
- int n)
+ public bool TestBit(int n)
{
if (n < 0)
throw new ArithmeticException("Bit position must not be negative");
@@ -3773,12 +3593,11 @@ namespace Org.BouncyCastle.Math
if (wordNum >= magnitude.Length)
return false;
- int word = magnitude[magnitude.Length - 1 - wordNum];
- return ((word >> (n % 32)) & 1) > 0;
+ uint word = magnitude[magnitude.Length - 1 - wordNum];
+ return ((word >> (n % 32)) & 1U) != 0;
}
- public BigInteger Or(
- BigInteger value)
+ public BigInteger Or(BigInteger value)
{
if (this.sign == 0)
return value;
@@ -3786,25 +3605,20 @@ namespace Org.BouncyCastle.Math
if (value.sign == 0)
return this;
- int[] aMag = this.sign > 0
- ? this.magnitude
- : Add(One).magnitude;
-
- int[] bMag = value.sign > 0
- ? value.magnitude
- : value.Add(One).magnitude;
+ uint[] aMag = this.sign > 0 ? this.magnitude : Add(One).magnitude;
+ uint[] bMag = value.sign > 0 ? value.magnitude : value.Add(One).magnitude;
bool resultNeg = sign < 0 || value.sign < 0;
int resultLength = System.Math.Max(aMag.Length, bMag.Length);
- int[] resultMag = new int[resultLength];
+ uint[] resultMag = new uint[resultLength];
int aStart = resultMag.Length - aMag.Length;
int bStart = resultMag.Length - bMag.Length;
for (int i = 0; i < resultMag.Length; ++i)
{
- int aWord = i >= aStart ? aMag[i - aStart] : 0;
- int bWord = i >= bStart ? bMag[i - bStart] : 0;
+ uint aWord = i >= aStart ? aMag[i - aStart] : 0U;
+ uint bWord = i >= bStart ? bMag[i - bStart] : 0U;
if (this.sign < 0)
{
@@ -3835,8 +3649,7 @@ namespace Org.BouncyCastle.Math
return result;
}
- public BigInteger Xor(
- BigInteger value)
+ public BigInteger Xor(BigInteger value)
{
if (this.sign == 0)
return value;
@@ -3844,26 +3657,21 @@ namespace Org.BouncyCastle.Math
if (value.sign == 0)
return this;
- int[] aMag = this.sign > 0
- ? this.magnitude
- : Add(One).magnitude;
-
- int[] bMag = value.sign > 0
- ? value.magnitude
- : value.Add(One).magnitude;
+ uint[] aMag = this.sign > 0 ? this.magnitude : Add(One).magnitude;
+ uint[] bMag = value.sign > 0 ? value.magnitude : value.Add(One).magnitude;
// TODO Can just replace with sign != value.sign?
bool resultNeg = (sign < 0 && value.sign >= 0) || (sign >= 0 && value.sign < 0);
int resultLength = System.Math.Max(aMag.Length, bMag.Length);
- int[] resultMag = new int[resultLength];
+ uint[] resultMag = new uint[resultLength];
int aStart = resultMag.Length - aMag.Length;
int bStart = resultMag.Length - bMag.Length;
for (int i = 0; i < resultMag.Length; ++i)
{
- int aWord = i >= aStart ? aMag[i - aStart] : 0;
- int bWord = i >= bStart ? bMag[i - bStart] : 0;
+ uint aWord = i >= aStart ? aMag[i - aStart] : 0U;
+ uint bWord = i >= bStart ? bMag[i - bStart] : 0U;
if (this.sign < 0)
{
@@ -3894,8 +3702,7 @@ namespace Org.BouncyCastle.Math
return result;
}
- public BigInteger SetBit(
- int n)
+ public BigInteger SetBit(int n)
{
if (n < 0)
throw new ArithmeticException("Bit address less than zero");
@@ -3910,8 +3717,7 @@ namespace Org.BouncyCastle.Math
return Or(One.ShiftLeft(n));
}
- public BigInteger ClearBit(
- int n)
+ public BigInteger ClearBit(int n)
{
if (n < 0)
throw new ArithmeticException("Bit address less than zero");
@@ -3926,8 +3732,7 @@ namespace Org.BouncyCastle.Math
return AndNot(One.ShiftLeft(n));
}
- public BigInteger FlipBit(
- int n)
+ public BigInteger FlipBit(int n)
{
if (n < 0)
throw new ArithmeticException("Bit address less than zero");
@@ -3939,15 +3744,14 @@ namespace Org.BouncyCastle.Math
return Xor(One.ShiftLeft(n));
}
- private BigInteger FlipExistingBit(
- int n)
+ private BigInteger FlipExistingBit(int n)
{
Debug.Assert(sign > 0);
Debug.Assert(n >= 0);
Debug.Assert(n < BitLength - 1);
- int[] mag = (int[]) this.magnitude.Clone();
- mag[mag.Length - 1 - (n >> 5)] ^= (1 << (n & 31)); // Flip bit
+ uint[] mag = (uint[])this.magnitude.Clone();
+ mag[mag.Length - 1 - (n >> 5)] ^= (1U << (n & 31)); // Flip bit
return new BigInteger(this.sign, mag, false);
}
}
|
