public static String UIRes(BigInt number)
{
String res = "";
int[] arr = new int[number.size];
Array.Copy(number.number, arr, number.size);
Array.Reverse(arr);
bool zero = true;
for (int i = 0; i < arr.Length; i++)
{
if (arr[i] != 0 || !zero)
{
res += arr[i];
zero = false;
}
}
return res;
}
/// <param name="number">Prints the BigInt</param>
///
public BigInt append(BigInt number)
{
int tmpsize = this.size + number.size;
int[] tmp = new int[tmpsize];
int c=0;
for (int i = 0; i < tmpsize; i++)
{
if (i <number.size)
tmp[i] = number.number[i];
else
{
tmp[i] = this.number[c];
c++;
}
}
BigInt res = new BigInt(tmp);
return res;
}
public static bool Prime(BigInt number)
{
BigInt random = new BigInt(2);
BigInt tmp =random ^ (number-new BigInt(1));
BigInt tmp2 = tmp % number;
BigInt x = new BigInt(1);
if (BigInt.equals(tmp2,x))
return true;
else
return false;
// return true;
}
public static void res(BigInt number)
{
Array.Reverse(number.number);
if (number.sign == false)
Console.Write('-');
bool zero = true;
for (int i = 0; i < number.size; i++)
{
if (number.number[i] != 0 || !zero)
{
Console.Write(number.index(i));
zero = false;
}
}
if (zero)
Console.Write(0);
//for (int i = 0; i < number.size; i++)
// Console.Write(number.index(i));
Console.Write("\n");
}
//////////////////////////////////////////////////////////////////////////////////
public static BigInt ModExp(BigInt B, BigInt P, BigInt M)
{
bool zero = true;
for (int i = 1; i < P.number.Length; i++)
{
if (P.number[i] != 0)
{
zero = false;
break;
}
}
if (zero && P.number[0] == 0)
return new BigInt(1);
else if (zero && P.number[0] == 1)
return B % M;
BigInt[] Pover_two;
BigInt two = new BigInt(2);
Pover_two = P / two;
BigInt res = ModExp(B, Pover_two[0], M);
if (!Even(P)) //if odd
{
// P.number[0]--;
res = res * res;
res = res * B;
return res % M;
// return (res * res * B) % M;
}
else
{
res = res * res;
return res % M;
// return (res * res) % M;
}
}
public static BigInt power(BigInt A, BigInt N)
{
bool zero = true;
for (int i = 0; i < N.number.Length; i++)
{
if (N.number[i] != 0)
{
zero = false;
break;
}
}
if (zero && N.number[0] == 0)
return new BigInt(1);
else if (zero && N.number[0] == 1)
return A;
BigInt[] pover_two;
BigInt two = new BigInt(2);
pover_two = N / two;
BigInt res = power(A, pover_two[0]);
if (!Even(N))
{
return res * res * A;
}
else
return res * res;
}
public static bool equals(BigInt number1, BigInt number2)
{
if (number1.size != number2.size)
return false;
else
{
for (int k = 0; k < number1.size; k++)
{
if (number1.number[k] != number2.number[k])
return false;
else if (number1.number[k] == number2.number[k])
continue;
}
return true;
}
}
/// <param name="number"></param>
/// <returns>"true" for even & "false" for odd</returns>
public static bool Even(BigInt number)
{
if (number.number[0] % 2 == 0)
return true;
else
return false;
}
public static BigInt En_Decrytion(BigInt ED, BigInt N, BigInt M)
{
BigInt result;
result = ModExp(M, ED, N);
return result;
}
/// <param name="number1"></param>
/// <param name="number2"></param>
/// <returns>"true" if number1 > number2 & "false" otherwise</returns>
public static bool operator >(BigInt number1, BigInt number2)
{
int mostLength = (number1.size > number2.size) ? number1.size : number2.size;
BigInt new_number1, new_number2;
if (number1.size != number2.size)
{
int[] Atemp = new int[mostLength];
Array.Copy(number1.number, 0, Atemp, 0, number1.size);
new_number1 = new BigInt(Atemp);
int[] Btemp = new int[mostLength];
Array.Copy(number2.number, 0, Btemp, 0, number2.size);
new_number2 = new BigInt(Btemp);
}
else
{
new_number1 = number1;
new_number2 = number2;
}
for (int i = mostLength - 1; i >= 0; i--)
{
if (new_number1.index(i) > new_number2.index(i))
return true;
else if (number1.index(i) < number2.index(i))
return false;
else
continue;
}
return false;
}
/// <param name="number1"></param>
/// <param name="number2"></param>
/// <returns>The divison of number1 / number2</returns>
public static BigInt[] operator /(BigInt number1, BigInt number2)
{
int mostLength = (number1.size > number2.size) ? number1.size : number2.size;
BigInt new_number1, new_number2;
if (mostLength > number1.size)
{
int[] number1temp = new int[mostLength];
Array.Copy(number1.number, 0, number1temp, 0, number1.size);
new_number1 = new BigInt(number1temp);
new_number2 = number2;
}
else if (mostLength > number2.size)
{
int[] number2temp = new int[mostLength];
Array.Copy(number2.number, 0, number2temp, 0, number2.size);
new_number2 = new BigInt(number2temp);
new_number1 = number1;
}
else
{
new_number1 = new BigInt(number1.number);
new_number2 = new BigInt(number2.number);
}
BigInt[] res = new BigInt[2];
if (new_number1 < new_number2)
{
res[0] = new BigInt(0);
res[1] = new_number1;
return res;
}
res = new_number1 / (new_number2 + new_number2);
res[0] = (res[0] + res[0]);
if ((res[1] < new_number2))
{
return res;
}
else
{
BigInt one = new BigInt(1);
res[0] = res[0] + one;
res[1] = res[1] - new_number2; //r - b
return res;
}
}
public static BigInt operator -(BigInt number1, BigInt number2)
{
int[] res;
BigInt result;
if (number1 < number2)
{
res = Subtract(number2.number, number1.number);
result = new BigInt(res);
result.sign = false;
}
else
{
res = Subtract(number1.number, number2.number);
result = new BigInt(res);
}
return result;
}
public BigInt(BigInt number)
{
this.size = number.size;
this.sign = number.sign;
Array.Copy(number.number, 0, this.number, 0, number.number.Length);
}
