private void InitFromString(string longInteger)
{
if (string.IsNullOrEmpty(longInteger))
{
throw new ArgumentException();
}
int digitCount = 0;
var result = new Integer(0);
var ten = new Integer(10);
var digits = new Dictionary <char, Integer>();
for (ulong i = '0'; i <= '9'; i++)
{
digits.Add(Convert.ToChar(i), new Integer(i - '0'));
}
foreach (var chr in longInteger.Reverse())
{
if (char.IsDigit(chr))
{
result = result + digits[chr] * IntegerMath.Pow(ten, digitCount);
digitCount++;
}
}
_digitCount = result._digitCount;
_digits = result._digits;
}
public static BigInteger LeastCommonMultiple(this BigInteger a, BigInteger b)
{
Extreme.Mathematics.BigInteger emA = ToUnsignedExtremeMathematics(a);
Extreme.Mathematics.BigInteger emB = ToUnsignedExtremeMathematics(b);
Extreme.Mathematics.BigInteger result = IntegerMath.LeastCommonMultiple(emA, emB);
return(ToUnsignedBigInteger(result));
}
public void Read(ref int[,] array, int offsetX, int offsetY, int width, int height, int min, int max)
{
int lastX = offsetX + width, lastY = offsetY + height;
int count = max - min;
int bits = IntegerMath.ILog2(IntegerMath.ToPowerOf2(Math.Abs(count)));
if (max >= 0)
{
for (int y = offsetY; y < lastY; y++)
{
for (int x = offsetX; x < lastX; x++)
{
array[x, y] = br.ReadBits(bits) + min;
}
}
}
else
{
for (int y = offsetY; y < lastY; y++)
{
for (int x = offsetX; x < lastX; x++)
{
array[x, y] = -br.ReadBits(bits) + min;
}
}
}
}
public static Polynomial Rem(Polynomial firstArg, Polynomial secondArg)
{
var firstDeg = firstArg.Deg;
var secondDeg = secondArg.Deg;
var newDeg = firstDeg - secondDeg;
var result = new ulong[newDeg + 1];
var reminder = (ulong[])firstArg._coefficients.Clone();
var mod = secondArg._mod;
ulong firstLc;
ulong secondLc = secondArg[secondDeg];
for (int i = 0; i <= newDeg; i++)
{
firstLc = reminder[firstDeg - i];
result[newDeg - i] = (firstLc * IntegerMath.Inverse(secondLc, mod)) % mod;
for (int j = 0; j <= secondDeg; j++)
{
reminder[firstDeg - secondDeg + j - i] =
(reminder[firstDeg - secondDeg + j - i] + (mod - (result[newDeg - i] * secondArg[j]) % mod)) % mod;
}
}
return(new Polynomial(reminder));
}
public static BigInteger GreatestCommonDivisor(this BigInteger a, BigInteger b)
{
Extreme.Mathematics.BigInteger emA = ToUnsignedExtremeMathematics(a);
Extreme.Mathematics.BigInteger emB = ToUnsignedExtremeMathematics(b);
Extreme.Mathematics.BigInteger result = IntegerMath.GreatestCommonDivisor(emA, emB);
return(ToUnsignedBigInteger(result));
}
static ulong[] InverseFft(ulong[] vector)
{
var size = vector.Length;
if (size == 1)
{
return(vector);
}
var evenVector = new ulong[size / 2];
var oddVector = new ulong[size / 2];
for (int i = 0; i < size / 2; i++)
{
evenVector[i] = vector[2 * i];
oddVector[i] = vector[2 * i + 1];
}
evenVector = InverseFft(evenVector);
oddVector = InverseFft(oddVector);
ulong pow = (ulong)(Power / size);
ulong root_n = IntegerMath.ModPow(Root_1, pow, Mod);
ulong w = 1;
var result = new ulong[size];
for (int i = 0; i < size / 2; i++)
{
result[i] = (Inverse * (evenVector[i] + (w * oddVector[i]) % Mod) % Mod) % Mod;
result[i + size / 2] =
(Inverse * (evenVector[i] + Mod - (w * oddVector[i]) % Mod) % Mod) % Mod;
w = (root_n * w) % Mod;
}
return(result);
}
void ReadBitStream(IO.EndianReader s, byte[] hashBuffer)
{
int max_bit_stream_size = GetBitStreamSize();
bool is_probably_from_mcc = hashBuffer.EqualsZero();
byte[] bs_bytes;
using (var hasher = Program.GetGen3RuntimeDataHasher())
{
int bs_length = ReadBitStreamSize(s, hasher, max_bit_stream_size, is_probably_from_mcc);
bs_bytes = new byte[IntegerMath.Align(IntegerMath.kInt32AlignmentBit, bs_length)];
s.Read(bs_bytes, bs_length);
hasher.TransformFinalBlock(bs_bytes, 0, bs_length);
InvalidData = hasher.Hash.EqualsArray(hashBuffer) == false;
}
if (RequireValidHashes && InvalidData)
{
Data = null;
}
else
{
using (var ms = new System.IO.MemoryStream(bs_bytes))
using (var bs = new IO.BitStream(ms, System.IO.FileAccess.Read, streamName: "GameVariant"))
{
bs.StreamMode = System.IO.FileAccess.Read;
Data.Serialize(bs);
}
}
}
public Polynomial FindPrimitiveRoot()
{
var eulerPhiFactorization = IntegerMath.Factorize(_cardinality - 1);
var one = new Polynomial(new ulong[] { 1 });
var zero = new Polynomial(new ulong[] { 0 });
var elements = GetAllElements();
foreach (var g in elements)
{
if (g != zero)
{
var tryNextelement = false;
foreach (var prime in eulerPhiFactorization.Keys)
{
if (Pow(g, (_cardinality - 1) / prime) == one)
{
tryNextelement = true;
break;
}
}
if (!tryNextelement)
{
return(g);
}
}
}
throw new OperationCanceledException("Корень не найден!");
}
public void Sqrt16Int()
{
int actual = IntegerMath.Sqrt(16);
int expected = 4;
Assert.AreEqual(expected, actual);
}
public void SqrtZeroLong()
{
long actual = IntegerMath.Sqrt(0L);
long expected = 0L;
Assert.AreEqual(expected, actual);
}
public void SqrtNineInt()
{
int actual = IntegerMath.Sqrt(9);
int expected = 3;
Assert.AreEqual(expected, actual);
}
public void SqrtZeroInt()
{
int actual = IntegerMath.Sqrt(0);
int expected = 0;
Assert.AreEqual(expected, actual);
}
public void SqrtMaxUlong()
{
ulong actual = IntegerMath.Sqrt(ulong.MaxValue);
ulong expected = 4294967295;
Assert.AreEqual(expected, actual);
}
public void IsPowerOfTwoTrueLargeLong()
{
long l = int.MaxValue;
++l;
Assert.IsTrue(IntegerMath.IsPowerOfTwo(l));
}
public void SqrtMidHighLong()
{
long actual = IntegerMath.Sqrt(3037000499L);
long expected = 55108L;
Assert.AreEqual(expected, actual);
}
public void SqrtMaxLong()
{
long actual = IntegerMath.Sqrt(long.MaxValue);
long expected = 3037000499L;
Assert.AreEqual(expected, actual);
}
public void SqrtNineLong()
{
long actual = IntegerMath.Sqrt(9L);
long expected = 3L;
Assert.AreEqual(expected, actual);
}
public void SqrtFourInt()
{
int actual = IntegerMath.Sqrt(4);
int expected = 2;
Assert.AreEqual(expected, actual);
}
public void Sqrt16Long()
{
long actual = IntegerMath.Sqrt(16L);
long expected = 4L;
Assert.AreEqual(expected, actual);
}
public void SqrtTwoLong()
{
long actual = IntegerMath.Sqrt(2L);
long expected = 1L;
Assert.AreEqual(expected, actual);
}
public void SqrtFourLong()
{
long actual = IntegerMath.Sqrt(4L);
long expected = 2L;
Assert.AreEqual(expected, actual);
}
private void button1_Click(object sender, RoutedEventArgs e)
{
try
{
ulong mod = ulong.Parse(modTb.Text);
var opr = checkBox1.IsChecked;
if (opr == true)
{
var roo = IntegerMath.FindPrimitiveRoot(mod);
var strBuilder = new StringBuilder();
strBuilder.Append(roo + ";" + Environment.NewLine);
ResultTb.Text = strBuilder + Environment.NewLine;
ResultTb.Text += "Найден один примитивный элемент!";
}
else
{
var roots = IntegerMath.FindAllPrimitiveRoots(mod);
var strBuilder = new StringBuilder();
int count = 0;
foreach (var root in roots)
{
count++;
strBuilder.Append(root + ";" + Environment.NewLine);
}
ResultTb.Text = strBuilder + Environment.NewLine;
ResultTb.Text += "Всего примитивных элементов в GF(" + mod + ") = " + count;
}
}
catch (Exception ex)
{
ResultTb.Text = "";
MessageBox.Show(ex.Message);
}
}
public void SqrtMaxInt()
{
int actual = IntegerMath.Sqrt(int.MaxValue);
int expected = 46340;
Assert.AreEqual(expected, actual);
}
public void SqrtTwoInt()
{
int actual = IntegerMath.Sqrt(2);
int expected = 1;
Assert.AreEqual(expected, actual);
}
private void CheckPowerOf2(string sName, int iValue)
{
if (IntegerMath.IsPowerOf2(iValue) == false)
{
throw new ArgumentException(sName + "(=" + iValue.ToString() + ") must be a power of two(like 2,4,8,32,64,...)!");
}
}
public void Sqrt16Sbyte()
{
sbyte value = 16;
sbyte actual = IntegerMath.Sqrt(value);
sbyte expected = 4;
Assert.AreEqual(expected, actual);
}
public void Sqrt16Ulong()
{
ulong value = 16;
ulong actual = IntegerMath.Sqrt(value);
ulong expected = 4;
Assert.AreEqual(expected, actual);
}
public void Sqrt16Short()
{
short value = 16;
short actual = IntegerMath.Sqrt(value);
short expected = 4;
Assert.AreEqual(expected, actual);
}
public void Sqrt10BigInteger()
{
BigInteger actual = 10;
actual = IntegerMath.Sqrt(actual);
BigInteger expected = 3;
Assert.AreEqual(expected, actual);
}
public void SqrtLargeBigInteger1()
{
BigInteger actual = long.MaxValue;
actual = IntegerMath.Sqrt((actual * actual) + 27);
BigInteger expected = long.MaxValue;
Assert.AreEqual(expected, actual);
}
