/**
* Computes <code>z * a(z) mod f(z)</code>, where <code>f(z)</code> is
* the reduction polynomial of <code>this</code>.
* @param a The polynomial <code>a(z)</code> to be multiplied by
* <code>z mod f(z)</code>.
* @return <code>z * a(z) mod f(z)</code>
*/
private BigInteger multZModF(
BigInteger a)
{
// Left-shift of a(z)
BigInteger az = a.ShiftLeft(1);
if (az.TestBit(this.m))
{
// If the coefficient of z^m in a(z) Equals 1, reduction
// modulo f(z) is performed: Add f(z) to to a(z):
// Step 1: Unset mth coeffient of a(z)
az = az.ClearBit(this.m);
// Step 2: Add r(z) to a(z), where r(z) is defined as
// f(z) = z^m + r(z), and k1, k2, k3 are the positions of
// the non-zero coefficients in r(z)
az = az.FlipBit(0);
az = az.FlipBit(this.k1);
if (this.representation == Ppb)
{
az = az.FlipBit(this.k2);
az = az.FlipBit(this.k3);
}
}
return(az);
}
public void TestClearBit()
{
Assert.AreEqual(Zero, Zero.ClearBit(0));
Assert.AreEqual(Zero, One.ClearBit(0));
Assert.AreEqual(Two, Two.ClearBit(0));
Assert.AreEqual(Zero, Zero.ClearBit(1));
Assert.AreEqual(One, One.ClearBit(1));
Assert.AreEqual(Zero, Two.ClearBit(1));
// TODO Tests for clearing bits in negative numbers
// TODO Tests for clearing extended bits
for (int i = 0; i < 10; ++i)
{
var n = new BigInteger(128, Rnd);
for (int j = 0; j < 10; ++j)
{
int pos = Rnd.Next(128);
BigInteger m = n.ClearBit(pos);
bool test = m.ShiftRight(pos).Remainder(Two).Equals(One);
Assert.IsFalse(test);
}
}
for (int i = 0; i < 100; ++i)
{
BigInteger pow2 = One.ShiftLeft(i);
BigInteger minusPow2 = pow2.Negate();
Assert.AreEqual(Zero, pow2.ClearBit(i));
Assert.AreEqual(minusPow2.ShiftLeft(1), minusPow2.ClearBit(i));
BigInteger bigI = BigInteger.ValueOf(i);
BigInteger negI = bigI.Negate();
for (int j = 0; j < 10; ++j)
{
string data = "i=" + i + ", j=" + j;
Assert.AreEqual(bigI.AndNot(One.ShiftLeft(j)), bigI.ClearBit(j), data);
Assert.AreEqual(negI.AndNot(One.ShiftLeft(j)), negI.ClearBit(j), data);
}
}
}
public static sbyte[] TauAdicNaf(sbyte mu, ZTauElement lambda)
{
if (mu != 1 && mu != -1)
{
throw new ArgumentException("mu must be 1 or -1");
}
BigInteger bigInteger = Tnaf.Norm(mu, lambda);
int bitLength = bigInteger.BitLength;
int num = (bitLength > 30) ? (bitLength + 4) : 34;
sbyte[] array = new sbyte[num];
int num2 = 0;
int num3 = 0;
BigInteger bigInteger2 = lambda.u;
BigInteger bigInteger3 = lambda.v;
while (!bigInteger2.Equals(BigInteger.Zero) || !bigInteger3.Equals(BigInteger.Zero))
{
if (bigInteger2.TestBit(0))
{
array[num2] = (sbyte)BigInteger.Two.Subtract(bigInteger2.Subtract(bigInteger3.ShiftLeft(1)).Mod(Tnaf.Four)).IntValue;
if (array[num2] == 1)
{
bigInteger2 = bigInteger2.ClearBit(0);
}
else
{
bigInteger2 = bigInteger2.Add(BigInteger.One);
}
num3 = num2;
}
else
{
array[num2] = 0;
}
BigInteger bigInteger4 = bigInteger2;
BigInteger bigInteger5 = bigInteger2.ShiftRight(1);
if (mu == 1)
{
bigInteger2 = bigInteger3.Add(bigInteger5);
}
else
{
bigInteger2 = bigInteger3.Subtract(bigInteger5);
}
bigInteger3 = bigInteger4.ShiftRight(1).Negate();
num2++;
}
num3++;
sbyte[] array2 = new sbyte[num3];
Array.Copy(array, 0, array2, 0, num3);
return(array2);
}
public static sbyte[] TauAdicNaf(sbyte mu, ZTauElement lambda)
{
if ((mu != 1) && (mu != -1))
{
throw new ArgumentException("mu must be 1 or -1");
}
int bitLength = Norm(mu, lambda).BitLength;
int num2 = (bitLength <= 30) ? 0x22 : (bitLength + 4);
sbyte[] sourceArray = new sbyte[num2];
int index = 0;
int length = 0;
BigInteger u = lambda.u;
BigInteger v = lambda.v;
while (!u.Equals(BigInteger.Zero) || !v.Equals(BigInteger.Zero))
{
if (u.TestBit(0))
{
sourceArray[index] = (sbyte)BigInteger.Two.Subtract(u.Subtract(v.ShiftLeft(1)).Mod(Four)).IntValue;
if (sourceArray[index] == 1)
{
u = u.ClearBit(0);
}
else
{
u = u.Add(BigInteger.One);
}
length = index;
}
else
{
sourceArray[index] = 0;
}
BigInteger integer4 = u;
BigInteger integer5 = u.ShiftRight(1);
if (mu == 1)
{
u = v.Add(integer5);
}
else
{
u = v.Subtract(integer5);
}
v = integer4.ShiftRight(1).Negate();
index++;
}
length++;
sbyte[] destinationArray = new sbyte[length];
Array.Copy(sourceArray, 0, destinationArray, 0, length);
return(destinationArray);
}
public void TestFlipBit()
{
for (int i = 0; i < 10; ++i)
{
BigInteger a = new BigInteger(128, 0, random);
BigInteger b = a;
for (int x = 0; x < 100; ++x)
{
// Note: Intentionally greater than initial size
int pos = random.Next(256);
a = a.FlipBit(pos);
b = b.TestBit(pos) ? b.ClearBit(pos) : b.SetBit(pos);
}
Assert.AreEqual(a, b);
}
for (int i = 0; i < 100; ++i)
{
BigInteger pow2 = one.ShiftLeft(i);
BigInteger minusPow2 = pow2.Negate();
Assert.AreEqual(zero, pow2.FlipBit(i));
Assert.AreEqual(minusPow2.ShiftLeft(1), minusPow2.FlipBit(i));
BigInteger bigI = BigInteger.ValueOf(i);
BigInteger negI = bigI.Negate();
for (int j = 0; j < 10; ++j)
{
string data = "i=" + i + ", j=" + j;
Assert.AreEqual(bigI.Xor(one.ShiftLeft(j)), bigI.FlipBit(j), data);
Assert.AreEqual(negI.Xor(one.ShiftLeft(j)), negI.FlipBit(j), data);
}
}
}
public void TestClearBit()
{
Assert.AreEqual(Zero, Zero.ClearBit(0));
Assert.AreEqual(Zero, One.ClearBit(0));
Assert.AreEqual(Two, Two.ClearBit(0));
Assert.AreEqual(Zero, Zero.ClearBit(1));
Assert.AreEqual(One, One.ClearBit(1));
Assert.AreEqual(Zero, Two.ClearBit(1));
// TODO Tests for clearing bits in negative numbers
// TODO Tests for clearing extended bits
for (int i = 0; i < 10; ++i)
{
var n = new BigInteger(128, Rnd);
for (int j = 0; j < 10; ++j)
{
int pos = Rnd.Next(128);
BigInteger m = n.ClearBit(pos);
bool test = m.ShiftRight(pos).Remainder(Two).Equals(One);
Assert.IsFalse(test);
}
}
for (int i = 0; i < 100; ++i)
{
BigInteger pow2 = One.ShiftLeft(i);
BigInteger minusPow2 = pow2.Negate();
Assert.AreEqual(Zero, pow2.ClearBit(i));
Assert.AreEqual(minusPow2.ShiftLeft(1), minusPow2.ClearBit(i));
BigInteger bigI = BigInteger.ValueOf(i);
BigInteger negI = bigI.Negate();
for (int j = 0; j < 10; ++j)
{
string data = "i=" + i + ", j=" + j;
Assert.AreEqual(bigI.AndNot(One.ShiftLeft(j)), bigI.ClearBit(j), data);
Assert.AreEqual(negI.AndNot(One.ShiftLeft(j)), negI.ClearBit(j), data);
}
}
}
/**
* Computes the <code>τ</code>-adic NAF (non-adjacent form) of an
* element <code>λ</code> of <code><b>Z</b>[τ]</code>.
* @param mu The parameter <code>μ</code> of the elliptic curve.
* @param lambda The element <code>λ</code> of
* <code><b>Z</b>[τ]</code>.
* @return The <code>τ</code>-adic NAF of <code>λ</code>.
*/
public static sbyte[] TauAdicNaf(sbyte mu, ZTauElement lambda)
{
if (!((mu == 1) || (mu == -1)))
{
throw new ArgumentException("mu must be 1 or -1");
}
BigInteger norm = Norm(mu, lambda);
// Ceiling of log2 of the norm
int log2Norm = norm.BitLength;
// If length(TNAF) > 30, then length(TNAF) < log2Norm + 3.52
int maxLength = log2Norm > 30 ? log2Norm + 4 : 34;
// The array holding the TNAF
sbyte[] u = new sbyte[maxLength];
int i = 0;
// The actual length of the TNAF
int length = 0;
BigInteger r0 = lambda.u;
BigInteger r1 = lambda.v;
while (!((r0.Equals(BigInteger.Zero)) && (r1.Equals(BigInteger.Zero))))
{
// If r0 is odd
if (r0.TestBit(0))
{
u[i] = (sbyte)BigInteger.Two.Subtract((r0.Subtract(r1.ShiftLeft(1))).Mod(Four)).IntValue;
// r0 = r0 - u[i]
if (u[i] == 1)
{
r0 = r0.ClearBit(0);
}
else
{
// u[i] == -1
r0 = r0.Add(BigInteger.One);
}
length = i;
}
else
{
u[i] = 0;
}
BigInteger t = r0;
BigInteger s = r0.ShiftRight(1);
if (mu == 1)
{
r0 = r1.Add(s);
}
else
{
// mu == -1
r0 = r1.Subtract(s);
}
r1 = t.ShiftRight(1).Negate();
i++;
}
length++;
// Reduce the TNAF array to its actual length
sbyte[] tnaf = new sbyte[length];
Array.Copy(u, 0, tnaf, 0, length);
return(tnaf);
}
public void ClearBit_pos_outside()
{
BigInteger x = new BigInteger(1, 0xFFFF0000, 0xFFFF0000);
BigInteger y = x.ClearBit(99);
Expect(y, SameAs(x));
}
public void ClearBit_pos_inside_initial_set()
{
BigInteger x = new BigInteger(1, 0xFFFF0000, 0xFFFF0000);
BigInteger w = new BigInteger(1, 0xFEFF0000, 0xFFFF0000);
BigInteger y = x.ClearBit(56);
Expect(y == w);
}
public void ClearBit_pos_inside_initial_clear()
{
BigInteger x = new BigInteger(1, 0xFFFF0000, 0xFFFF0000);
BigInteger y = x.ClearBit(39);
Expect(y, SameAs(x));
}
public void ClearBit_neg_outside()
{
BigInteger x = new BigInteger(-1, 0xFFFF0000, 0xFFFF0000);
BigInteger y = x.ClearBit(99);
Expect(SameValue(y, -1, new uint[] { 8, 0, 0xFFFF0000, 0xFFFF0000 }));
}
public void ClearBit_neg_inside_initial_set()
{
BigInteger x = new BigInteger(-1, 0xFFFF0000, 0xFFFF0000);
BigInteger y = x.ClearBit(39);
Expect(SameValue(y, -1, new uint[] { 0xFFFF0080, 0xFFFF0000 }));
}
/// <summary>
/// Chooses the nth particular prime which is lower than the startValue
/// </summary>
/// <param name="startValue">The value which we start to look for a prime from</param>
/// <param name="e">Exponent</param>
/// <param name="n">The index of the prime</param>
/// <returns></returns>
protected BigInteger ChooseNthPrime(BigInteger startValue, BigInteger e, int n, int bitLength)
{
bool eIsKnownOddPrime = (e.BitLength <= SPECIAL_E_BITS) && Arrays.Contains(SPECIAL_E_VALUES, e.IntValue);
BigInteger p = new BigInteger(startValue.ToByteArray());
while (true)
{
if (p.BitLength > bitLength)
{
Console.WriteLine($" -NOTE- The bitrate raised from {bitLength} to {p.BitLength}, so we reset our p value.");
p = p.ClearBit(bitLength);
}
if (p.BitLength < bitLength)
{
Console.WriteLine($" -NOTE- The bitrate dropped from {bitLength} to {p.BitLength}, so we reset our p value.");
p = p.SetBit(bitLength - 1);
}
if (n > 0)
{
// Add one to p in an efficient way
for (int i = 0; i <= p.BitLength; i++)
{
if (!p.TestBit(i))
{
p = p.SetBit(i);
break;
}
p = p.ClearBit(i);
}
}
else if (n < 0)
{
// Subtract one from p in an efficient way
int lsb = p.GetLowestSetBit();
p = p.ClearBit(lsb);
for (int i = 0; i < lsb; i++)
{
p = p.SetBit(i);
}
}
if (!p.TestBit(0))
{
continue;
}
if (p.Mod(e).Equals(One))
{
continue;
}
if (!p.IsProbablePrime(this.parameters.Certainty))
{
continue;
}
if (!eIsKnownOddPrime && !e.Gcd(p.Subtract(One)).Equals(One))
{
continue;
}
// p is a prime
if (n > 0)
{
n--;
}
else if (n < 0)
{
n++;
}
if (n == 0)
{
break;
}
}
return(p);
}
public static sbyte[] TauAdicNaf(sbyte mu, ZTauElement lambda)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
if (mu != 1 && mu != -1)
{
throw new ArgumentException("mu must be 1 or -1");
}
BigInteger bigInteger = Norm(mu, lambda);
int bitLength = bigInteger.BitLength;
int num = ((bitLength > 30) ? (bitLength + 4) : 34);
sbyte[] array = new sbyte[num];
int num2 = 0;
int num3 = 0;
BigInteger bigInteger2 = lambda.u;
BigInteger bigInteger3 = lambda.v;
while (!bigInteger2.Equals(BigInteger.Zero) || !bigInteger3.Equals(BigInteger.Zero))
{
if (bigInteger2.TestBit(0))
{
array[num2] = (sbyte)BigInteger.Two.Subtract(bigInteger2.Subtract(bigInteger3.ShiftLeft(1)).Mod(Four)).IntValue;
bigInteger2 = ((array[num2] != 1) ? bigInteger2.Add(BigInteger.One) : bigInteger2.ClearBit(0));
num3 = num2;
}
else
{
array[num2] = 0;
}
BigInteger bigInteger4 = bigInteger2;
BigInteger bigInteger5 = bigInteger2.ShiftRight(1);
bigInteger2 = ((mu != 1) ? bigInteger3.Subtract(bigInteger5) : bigInteger3.Add(bigInteger5));
bigInteger3 = bigInteger4.ShiftRight(1).Negate();
num2++;
}
num3++;
sbyte[] array2 = new sbyte[num3];
global::System.Array.Copy((global::System.Array)array, 0, (global::System.Array)array2, 0, num3);
return(array2);
}
