public void LongSquareNumberTest()
{
int n = 23 * 1024 - 731;
ulong[] input1 = new ulong[n];
ulong[] result1 = new ulong[n * 2];
ulong[] result2 = new ulong[n * 2];
ulong[] result3 = new ulong[n * 2];
Random random = new Random(1001);
for (int i = n; --i >= 0;)
{
input1[i] = getUlong(random);
}
AsmX64Operations.SetKaratsubaBreakPoint(16);
AsmX64Operations.SetFourierBreakPoint(12 * 1024);
AsmX64Operations.FastestSquare(input1, result1, n, false);
AsmX64Operations.KaratsubaSquare(input1, result2, n);
AsmX64Operations.Square(input1, result3, n);
for (int i = n * 2; --i >= 0;)
{
if (result1[i] != result2[i] || result2[i] != result3[i])
{
Assert.IsTrue(false);
return;
}
}
Assert.IsTrue(true);
}
public void ProgressiveMultiplicationNumberTest()
{
AsmX64Operations.SetKaratsubaBreakPoint(16);
AsmX64Operations.SetFourierBreakPoint(512);
for (int n = 1; n < 2048; n++)
{
ulong[] input1 = new ulong[n];
ulong[] input2 = new ulong[n];
ulong[] result1 = new ulong[n * 2];
ulong[] result2 = new ulong[n * 2];
ulong[] result3 = new ulong[n * 2];
Random random = new Random(1001);
for (int i = n; --i >= 0;)
{
input1[i] = getUlong(random);
input2[i] = getUlong(random);
}
AsmX64Operations.FastestMultiplication(input1, input2, result1, n, false);
AsmX64Operations.Karatsuba(input1, input2, result2, n);
AsmX64Operations.Multiply(input1, input2, result3, n);
for (int i = n * 2; --i >= 0;)
{
if (result1[i] != result2[i] || result2[i] != result3[i])
{
Assert.IsTrue(false);
return;
}
}
}
Assert.IsTrue(true);
}
public void GeneralRealNumberTest()
{
var no0 = new RealNumber(1L << 62, 4096 / 64);
var no1 = no0.GetExp();
var no2 = no1.GetLog();
var no3 = no0.GetTaylorExp();
var no4 = no3.GetLog();
no0 = no0.ChangePrecision(no0.GetPrecisionDigits() - 10);
no1 = no1.ChangePrecision(no1.GetPrecisionDigits() - 10);
no2 = no2.ChangePrecision(no2.GetPrecisionDigits() - 10);
no3 = no3.ChangePrecision(no3.GetPrecisionDigits() - 10);
no4 = no4.ChangePrecision(no4.GetPrecisionDigits() - 10);
bool ok = (no2 - no0).IsZero && (no4 - no0).IsZero;
ulong[] xx = Enumerable.Repeat(ulong.MaxValue, 1024 * 48).ToArray();
ulong[] yy = Enumerable.Repeat(ulong.MaxValue, 1024 * 48).ToArray();
ulong[] zz = Enumerable.Repeat((ulong)0, 1024 * 48 * 2).ToArray();
AsmX64Operations.FastestMultiplication(xx, yy, zz, xx.Length);
if (zz[0] != 1 || zz[zz.Length / 2 - 1] != 0 || zz[zz.Length / 2] + 2 != 0 || zz[zz.Length - 1] + 1 != 0)
{
ok = false;
}
Assert.IsTrue(ok);
}
static void testMultiplicationSpeed()
{
Random random = new Random(1001);
byte[] number = new byte[16];
int n = 4;
int iterations = 1000000;
while (true)
{
AsmX64Operations.SetKaratsubaBreakPoint(n);
ulong[] a = new ulong[n];
ulong[] b = new ulong[n];
ulong[] c = new ulong[n * 2];
ulong[] tk = new ulong[AsmX64Operations.GetKaratsubaMultiplicationBufferSize(n)];
for (int i = n; --i >= 0;)
{
random.NextBytes(number);
a[i] = BitConverter.ToUInt64(number, 0);
b[i] = BitConverter.ToUInt64(number, 8);
}
var directTime = AsmX64Operations.MeasureTime(() =>
{
for (int i = iterations; --i >= 0;)
{
AsmX64Operations.Multiply(a, b, c, n);
}
});
var karaTime = AsmX64Operations.MeasureTime(() =>
{
for (int i = iterations; --i >= 0;)
{
AsmX64Operations.Karatsuba(a, b, c, n, tk);
}
});
if (karaTime.TotalSeconds < directTime.TotalSeconds)
{
break;
}
n++;
}
MessageBox.Show("Kara break point = " + n.ToString());
iterations = 100;
//AsmX64Operations.SetKaratsubaBreakPoint(14);
n = 4 * 1024;
while (true)
{
AsmX64Operations.SetFourierBreakPoint(n);
ulong[] a = new ulong[n];
ulong[] b = new ulong[n];
ulong[] c = new ulong[n * 2];
ulong[] tk = new ulong[AsmX64Operations.GetKaratsubaMultiplicationBufferSize(n)];
for (int i = n; --i >= 0;)
{
random.NextBytes(number);
a[i] = BitConverter.ToUInt64(number, 0);
b[i] = BitConverter.ToUInt64(number, 8);
}
var karaTime = AsmX64Operations.MeasureTime(() =>
{
for (int i = iterations; --i >= 0;)
{
AsmX64Operations.Karatsuba(a, b, c, n, tk);
}
});
var fourierTime = AsmX64Operations.MeasureTime(() =>
{
for (int i = iterations; --i >= 0;)
{
AsmX64Operations.FourierMultiplication(a, b, c, n);
}
});
if (fourierTime.TotalSeconds < karaTime.TotalSeconds)
{
break;
}
n += 512;
}
MessageBox.Show("Fourier break point = " + n.ToString());
}
public void TestAll()
{
for (int digits = 1; digits < 100; digits++)
{
RealNumber b_one = new RealNumber(2L, digits);
RealNumber log1 = RealNumber.Zero, log2 = RealNumber.Zero;
Parallel.Invoke(
() =>
{
log1 = b_one.GetLog();
},
() =>
{
log2 = b_one.GetTaylorLog();
});
string log1String = log1.ToString();
string log2String = log2.ToString();
int diffs = differences(log2String, log1String);
if (diffs > 0)
{
File.WriteAllText("L1MILD.txt", log1String);
File.WriteAllText("L1MILT.txt", log2String);
Assert.IsTrue(false);
}
}
//IntegerNumber zzz = new IntegerNumber(0L);
//string ssttrr = zzz.ToString();
bool ok = true;
//testMultiplicationSpeed();
RealNumber ten = new RealNumber(10, 1000);
RealNumber logTen = ten.GetLog();
RealNumber tenExp1 = logTen.GetExp();
RealNumber tenExp2 = logTen.GetTaylorExp();
IntegerNumber i1 = IntegerNumber.One << 100000;
IntegerNumber ia = i1.Sqrt();
IntegerNumber ib = i1.InverseSqrt();
RealNumber ssqrt10 = ten.GetRealDirectSqrt();
RealNumber sqrt10 = ten.GetSqrt();
RealNumber invSqrt10 = ten.GetInverseSqrt();
RealNumber one1 = sqrt10 * invSqrt10;
ok &= (one1 - 1).IsZero;
IntegerNumber int10 = IntegerNumber.Pow(10, 19 * 5000);
IntegerNumber t1 = int10.Inverse();
IntegerNumber t2 = (IntegerNumber.One << (int10.Digits * 128)) / int10;
ok &= t1 == t2;
IntegerNumber t3 = int10.InverseSqrt();
IntegerNumber t4 = ((IntegerNumber.One << (int10.Digits * 96 * 2)) / int10).Sqrt();
ok &= t3 == t4;
ok &= Fourier235RealUnitTest.FFTUnitTest();
ok &= Fourier235RealUnitTest.DCTUnitTest();
ok &= Fourier235DoubleUnitTest.FFTUnitTest();
ok &= Fourier235DoubleUnitTest.DCTUnitTest();
ok &= Fourier235UnitTest.FFTUnitTest();
ok &= Fourier235UnitTest.DCTUnitTest();
ok &= RealNumbersUnitTest.ComplexArcTanSinCosUnitTest();
ok &= RealNumbersUnitTest.NumericIntegerOperationsUnitTest();
ok &= RealNumbersUnitTest.SqrtUnitTest();
ok &= MemoryUnitTest.UnitTest(1001);
ok &= CarrylessMultiplication.UnitTest(1001);
int decimalDigits = 10100;
int qwords = (int)Math.Ceiling(Math.Log(10, 2) * decimalDigits / 64);
RealNumber pi = RealNumber.Zero;
RealNumber e = RealNumber.Zero;
RealNumber one = new RealNumber(1L, qwords);
var computePITime = AsmX64Operations.MeasureTime(() =>
{
pi = RealNumber.GetPI(qwords);
});
var computeETime = AsmX64Operations.MeasureTime(() =>
{
e = one.GetExp();
});
string pivalue = "";
string evalue = "";
var baseConvertTimePI = AsmX64Operations.MeasureTime(() =>
{
pivalue = pi.ToString();
});
var baseConvertTimeE = AsmX64Operations.MeasureTime(() =>
{
evalue = e.ToString();
});
File.WriteAllText(@"..\pi10k.txt", pivalue);
File.WriteAllText(@"..\e_10k.txt", evalue);
//MessageBox.Show(
// "Compute PI Time: " + computePITime.ToString() + "\r\n" +
// "Compute E Time: " + computeETime.ToString() + "\r\n" +
// "base convert time PI: " + baseConvertTimePI.ToString() + "\r\n" +
// "base convert time E : " + baseConvertTimeE.ToString() + "\r\n",
// "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
var no0 = new RealNumber(1L << 62, 2048 / 64);
var no1 = no0.GetExp();
var no2 = no1.GetLog();
ok &= (no2 - no0).IsZero;
ulong[] xx = Enumerable.Repeat(ulong.MaxValue, 1024 * 100).ToArray();
ulong[] yy = Enumerable.Repeat(ulong.MaxValue, 1024 * 100).ToArray();
ulong[] zz = Enumerable.Repeat((ulong)0, 1024 * 200).ToArray();
AsmX64Operations.FastestMultiplication(xx, yy, zz, xx.Length);
if (zz[0] != 1 || zz[zz.Length / 2 - 1] != 0 || zz[zz.Length / 2] + 2 != 0 || zz[zz.Length - 1] + 1 != 0)
{
ok = false;
}
ok &= RealNumbersUnitTest.UnitTest(1001);
ok &= FourierReal.UnitTest(10012);
ok &= FourierMultiplication.UnitTest();
ok &= IntegerNumberUnitTest.UnitTest();
ok &= FourierMultiplication.UnitTestBigMul(1001);
ok &= FastIntegerUnitTest.UnitTest();
ok &= FourierMultiplication.UnitTest(1001);
ok &= AsmX64Operations.ECCUnitTest();
ok &= AsmX64Operations.UnitTest();
ok &= HeapUnitTest.UnitTest();
ok &= FourierTransform.FFTUnitTest();
ok &= AccurateSummation.UnitTest();
ok &= BinarySearchUnitTest.UnitTest();
ok &= AVLTree <int> .UnitTest();
ok &= AVLTreeSorted <int> .UnitTest();
Assert.IsTrue(ok);
}
public void AsmX64OperationsUnitTestMethod()
{
bool ok = AsmX64Operations.UnitTest();
Assert.IsTrue(ok);
}
