/**
* return a sqrt root - the routine verifies that the calculation returns the right value - if
* none exists it returns null.
*/
public override ECFieldElement Sqrt()
{
// Raise this element to the exponent 2^382 - 2^126 - 2^94 + 2^30
uint[] x1 = this.x;
if (Nat.IsZero(12, x1) || Nat.IsOne(12, x1))
return this;
uint[] t1 = Nat.Create(12);
uint[] t2 = Nat.Create(12);
uint[] t3 = Nat.Create(12);
uint[] t4 = Nat.Create(12);
SecP384R1Field.Square(x1, t1);
SecP384R1Field.Multiply(t1, x1, t1);
SecP384R1Field.SquareN(t1, 2, t2);
SecP384R1Field.Multiply(t2, t1, t2);
SecP384R1Field.Square(t2, t2);
SecP384R1Field.Multiply(t2, x1, t2);
SecP384R1Field.SquareN(t2, 5, t3);
SecP384R1Field.Multiply(t3, t2, t3);
SecP384R1Field.SquareN(t3, 5, t4);
SecP384R1Field.Multiply(t4, t2, t4);
SecP384R1Field.SquareN(t4, 15, t2);
SecP384R1Field.Multiply(t2, t4, t2);
SecP384R1Field.SquareN(t2, 2, t3);
SecP384R1Field.Multiply(t1, t3, t1);
SecP384R1Field.SquareN(t3, 28, t3);
SecP384R1Field.Multiply(t2, t3, t2);
SecP384R1Field.SquareN(t2, 60, t3);
SecP384R1Field.Multiply(t3, t2, t3);
uint[] r = t2;
SecP384R1Field.SquareN(t3, 120, r);
SecP384R1Field.Multiply(r, t3, r);
SecP384R1Field.SquareN(r, 15, r);
SecP384R1Field.Multiply(r, t4, r);
SecP384R1Field.SquareN(r, 33, r);
SecP384R1Field.Multiply(r, t1, r);
SecP384R1Field.SquareN(r, 64, r);
SecP384R1Field.Multiply(r, x1, r);
SecP384R1Field.SquareN(r, 30, t1);
SecP384R1Field.Square(t1, t2);
return Nat.Eq(12, x1, t2) ? new SecP384R1FieldElement(t1) : null;
}
public override ECFieldElement Sqrt()
{
uint[] array = x;
if (Nat.IsZero(17, array) || Nat.IsOne(17, array))
{
return(this);
}
uint[] z = Nat.Create(17);
uint[] array2 = Nat.Create(17);
SecP521R1Field.SquareN(array, 519, z);
SecP521R1Field.Square(z, array2);
return((!Nat.Eq(17, array, array2)) ? null : new SecP521R1FieldElement(z));
}
public override ECFieldElement Sqrt()
{
uint[] x = this.x;
if (Nat.IsZero(0x11, x) || Nat.IsOne(0x11, x))
{
return(this);
}
uint[] z = Nat.Create(0x11);
uint[] numArray3 = Nat.Create(0x11);
SecP521R1Field.SquareN(x, 0x207, z);
SecP521R1Field.Square(z, numArray3);
return(!Nat.Eq(0x11, x, numArray3) ? null : new SecP521R1FieldElement(z));
}
public override ECFieldElement Sqrt()
{
uint[] y = this.x;
if (Nat.IsZero(12, y) || Nat.IsOne(12, y))
{
return(this);
}
uint[] array = Nat.Create(12);
uint[] array2 = Nat.Create(12);
uint[] array3 = Nat.Create(12);
uint[] array4 = Nat.Create(12);
SecP384R1Field.Square(y, array);
SecP384R1Field.Multiply(array, y, array);
SecP384R1Field.SquareN(array, 2, array2);
SecP384R1Field.Multiply(array2, array, array2);
SecP384R1Field.Square(array2, array2);
SecP384R1Field.Multiply(array2, y, array2);
SecP384R1Field.SquareN(array2, 5, array3);
SecP384R1Field.Multiply(array3, array2, array3);
SecP384R1Field.SquareN(array3, 5, array4);
SecP384R1Field.Multiply(array4, array2, array4);
SecP384R1Field.SquareN(array4, 15, array2);
SecP384R1Field.Multiply(array2, array4, array2);
SecP384R1Field.SquareN(array2, 2, array3);
SecP384R1Field.Multiply(array, array3, array);
SecP384R1Field.SquareN(array3, 28, array3);
SecP384R1Field.Multiply(array2, array3, array2);
SecP384R1Field.SquareN(array2, 60, array3);
SecP384R1Field.Multiply(array3, array2, array3);
uint[] z = array2;
SecP384R1Field.SquareN(array3, 120, z);
SecP384R1Field.Multiply(z, array3, z);
SecP384R1Field.SquareN(z, 15, z);
SecP384R1Field.Multiply(z, array4, z);
SecP384R1Field.SquareN(z, 33, z);
SecP384R1Field.Multiply(z, array, z);
SecP384R1Field.SquareN(z, 64, z);
SecP384R1Field.Multiply(z, y, z);
SecP384R1Field.SquareN(z, 30, array);
SecP384R1Field.Square(array, array2);
if (!Nat.Eq(12, y, array2))
{
return(null);
}
return(new SecP384R1FieldElement(array));
}
/**
* return a sqrt root - the routine verifies that the calculation returns the right value - if
* none exists it returns null.
*/
public override ECFieldElement Sqrt()
{
// Raise this element to the exponent 2^519
uint[] x1 = this.x;
if (Nat.IsZero(17, x1) || Nat.IsOne(17, x1))
{
return(this);
}
uint[] t1 = Nat.Create(17);
uint[] t2 = Nat.Create(17);
SecP521R1Field.SquareN(x1, 519, t1);
SecP521R1Field.Square(t1, t2);
return(Nat.Eq(17, x1, t2) ? new SecP521R1FieldElement(t1) : null);
}
public override ECFieldElement Sqrt()
{
uint[] x = this.x;
if (Nat.IsZero(12, x) || Nat.IsOne(12, x))
{
return(this);
}
uint[] z = Nat.Create(12);
uint[] numArray3 = Nat.Create(12);
uint[] numArray4 = Nat.Create(12);
uint[] numArray5 = Nat.Create(12);
SecP384R1Field.Square(x, z);
SecP384R1Field.Multiply(z, x, z);
SecP384R1Field.SquareN(z, 2, numArray3);
SecP384R1Field.Multiply(numArray3, z, numArray3);
SecP384R1Field.Square(numArray3, numArray3);
SecP384R1Field.Multiply(numArray3, x, numArray3);
SecP384R1Field.SquareN(numArray3, 5, numArray4);
SecP384R1Field.Multiply(numArray4, numArray3, numArray4);
SecP384R1Field.SquareN(numArray4, 5, numArray5);
SecP384R1Field.Multiply(numArray5, numArray3, numArray5);
SecP384R1Field.SquareN(numArray5, 15, numArray3);
SecP384R1Field.Multiply(numArray3, numArray5, numArray3);
SecP384R1Field.SquareN(numArray3, 2, numArray4);
SecP384R1Field.Multiply(z, numArray4, z);
SecP384R1Field.SquareN(numArray4, 0x1c, numArray4);
SecP384R1Field.Multiply(numArray3, numArray4, numArray3);
SecP384R1Field.SquareN(numArray3, 60, numArray4);
SecP384R1Field.Multiply(numArray4, numArray3, numArray4);
uint[] numArray6 = numArray3;
SecP384R1Field.SquareN(numArray4, 120, numArray6);
SecP384R1Field.Multiply(numArray6, numArray4, numArray6);
SecP384R1Field.SquareN(numArray6, 15, numArray6);
SecP384R1Field.Multiply(numArray6, numArray5, numArray6);
SecP384R1Field.SquareN(numArray6, 0x21, numArray6);
SecP384R1Field.Multiply(numArray6, z, numArray6);
SecP384R1Field.SquareN(numArray6, 0x40, numArray6);
SecP384R1Field.Multiply(numArray6, x, numArray6);
SecP384R1Field.SquareN(numArray6, 30, z);
SecP384R1Field.Square(z, numArray3);
return(!Nat.Eq(12, x, numArray3) ? null : new SecP384R1FieldElement(z));
}
private static int Legendre(BigInteger a, BigInteger b)
{
//int r = 0, bits = b.IntValue;
//for (;;)
//{
// int lowestSetBit = a.GetLowestSetBit();
// a = a.ShiftRight(lowestSetBit);
// r ^= (bits ^ (bits >> 1)) & (lowestSetBit << 1);
// int cmp = a.CompareTo(b);
// if (cmp == 0)
// break;
// if (cmp < 0)
// {
// BigInteger t = a; a = b; b = t;
// int oldBits = bits;
// bits = b.IntValue;
// r ^= oldBits & bits;
// }
// a = a.Subtract(b);
//}
//return BigInteger.One.Equals(b) ? (1 - (r & 2)) : 0;
int bitLength = b.BitLength;
uint[] A = Nat.FromBigInteger(bitLength, a);
uint[] B = Nat.FromBigInteger(bitLength, b);
int r = 0;
int len = B.Length;
for (;;)
{
while (A[0] == 0)
{
Nat.ShiftDownWord(len, A, 0);
}
int shift = Integers.NumberOfTrailingZeros((int)A[0]);
if (shift > 0)
{
Nat.ShiftDownBits(len, A, shift, 0);
int bits = (int)B[0];
r ^= (bits ^ (bits >> 1)) & (shift << 1);
}
int cmp = Nat.Compare(len, A, B);
if (cmp == 0)
{
break;
}
if (cmp < 0)
{
r ^= (int)(A[0] & B[0]);
uint[] t = A; A = B; B = t;
}
while (A[len - 1] == 0)
{
len = len - 1;
}
Nat.Sub(len, A, B, A);
}
return(Nat.IsOne(len, B) ? (1 - (r & 2)) : 0);
}
public static void Invert(uint[] p, uint[] x, uint[] z)
{
int num = p.Length;
if (Nat.IsZero(num, x))
{
throw new ArgumentException("cannot be 0", "x");
}
if (Nat.IsOne(num, x))
{
Array.Copy(x, 0, z, 0, num);
return;
}
uint[] array = Nat.Copy(num, x);
uint[] array2 = Nat.Create(num);
array2[0] = 1u;
int xc = 0;
if ((array[0] & 1) == 0)
{
InversionStep(p, array, num, array2, ref xc);
}
if (Nat.IsOne(num, array))
{
InversionResult(p, xc, array2, z);
return;
}
uint[] array3 = Nat.Copy(num, p);
uint[] array4 = Nat.Create(num);
int xc2 = 0;
int num2 = num;
while (true)
{
if (array[num2 - 1] == 0 && array3[num2 - 1] == 0)
{
num2--;
}
else if (Nat.Gte(num, array, array3))
{
Nat.SubFrom(num, array3, array);
xc += Nat.SubFrom(num, array4, array2) - xc2;
InversionStep(p, array, num2, array2, ref xc);
if (Nat.IsOne(num, array))
{
InversionResult(p, xc, array2, z);
return;
}
}
else
{
Nat.SubFrom(num, array, array3);
xc2 += Nat.SubFrom(num, array2, array4) - xc;
InversionStep(p, array3, num2, array4, ref xc2);
if (Nat.IsOne(num, array3))
{
break;
}
}
}
InversionResult(p, xc2, array4, z);
}
