void genparams( ZZ &p, ZZ &q, ZZ &a)
{
long err = 80;
GenPrime(q, N, err);
ZZ m;
RandomLen(m, L-N);
cout << "\nGenerating p, q and a...\n";
long NumTrials = 20;
for (long i = 0; i < 10000; i++, m++)
{
p = q * m + 1;
if (ProbPrime(p, NumTrials))
{
// cout << "\ni = " << i << endl;
// cout << "OK" << endl;
break;
}
}
ZZ d, f;
// ZZ f1 = ((p-1) * InvMod(q, p)) % p;
ZZ f1 = m; // = (p-1)/q
for( d = 2; a == 0; d++ )
{
f = PowerMod(d%p, f1%p, p);
if ( f > 1 )
{
a = f;
// cout << a << " ";
break;
}
}
cout << "\np = \n"; show_dec_in_hex (p, L); cout << endl;
cout << "\nq = \n"; show_dec_in_hex (q, N); cout << endl;
cout << "\na = \n"; show_dec_in_hex (a, L); cout << endl;
}
int main()
{
RR::SetPrecision(150);
long n, b, size;
cerr << "n: ";
cin >> n;
cerr << "b: ";
cin >> b;
cerr << "size: ";
cin >> size;
cerr << "prune: ";
long prune;
cin >> prune;
ZZ seed;
cerr << "seed: ";
cin >> seed;
if (seed != 0)
SetSeed(seed);
char alg;
cerr << "alg [fqQxr]: ";
cin >> alg;
double TotalTime = 0;
long TotalSucc = 0;
long iter;
for (iter = 1; iter <= 20; iter++) {
vec_ZZ a;
a.SetLength(n);
ZZ bound;
LeftShift(bound, to_ZZ(1), b);
long i;
for (i = 1; i <= n; i++) {
RandomBnd(a(i), bound);
a(i) += 1;
}
ZZ S;
do {
RandomLen(S, n+1);
} while (weight(S) != n/2+1);
ZZ s;
clear(s);
for (i = 1; i <= n; i++)
if (bit(S, i-1))
s += a(i);
mat_ZZ B(INIT_SIZE, n+1, n+3);
for (i = 1; i <= n; i++) {
B(i, i) = 2;
B(i, n+1) = a(i) * n;
B(i, n+3) = n;
}
for (i = 1; i <= n; i++)
B(n+1, i) = 1;
B(n+1, n+1) = s * n;
B(n+1, n+2) = 1;
B(n+1, n+3) = n;
B(n+1, n+3) *= n/2;
swap(B(1), B(n+1));
for (i = 2; i <= n; i++) {
long j = RandomBnd(n-i+2) + i;
swap(B(i), B(j));
}
double t;
LLLStatusInterval = 10;
t = GetTime();
switch (alg) {
case 'f':
BKZ_FP(B, 0.99, size, prune, SubsetSumSolution);
break;
case 'q':
BKZ_QP(B, 0.99, size, prune, SubsetSumSolution);
break;
case 'Q':
BKZ_QP1(B, 0.99, size, prune, SubsetSumSolution);
break;
case 'x':
BKZ_XD(B, 0.99, size, prune, SubsetSumSolution);
break;
case 'r':
BKZ_RR(B, 0.99, size, prune, SubsetSumSolution);
break;
default:
Error("invalid algorithm");
}
t = GetTime()-t;
long succ = 0;
for (i = 1; i <= n+1; i++)
if (SubsetSumSolution(B(i)))
succ = 1;
TotalTime += t;
TotalSucc += succ;
if (succ)
cerr << "+";
else
cerr << "-";
}
cerr << "\n";
cerr << "number of success: " << TotalSucc << "\n";
cerr << "average time: " << TotalTime/20 << "\n";
return 0;
}
int main()
{
setbuf(stdout, NULL);
SetSeed(ZZ(0));
for (long l = 256; l <= 16384; l *= 2) {
// for (long n = 256; n <= 16384; n *= 2) {
for (long idx = 0; idx < 13; idx ++) {
long n = 256*(1L << idx/2);
if (idx & 1) n += n/2;
SetSeed((ZZ(l) << 64) + ZZ(n));
ZZ p;
RandomLen(p, l);
if (!IsOdd(p)) p++;
ZZ_p::init(p);
ZZ_pX a, c, f;
random(a, n);
random(f, n);
SetCoeff(f, n);
ZZ_pXModulus F(f);
double t;
SqrMod(c, a, F);
long iter = 1;
do {
t = GetTime();
for (long i = 0; i < iter; i++) SqrMod(c, a, F);
t = GetTime() - t;
iter *= 2;
} while (t < 3);
iter /= 2;
t = GetTime();
for (long i = 0; i < iter; i++) SqrMod(c, a, F);
t = GetTime()-t;
double NTLTime = t;
FlintZZ_pX f_a(a), f_c, f_f(f), f_finv;
fmpz_mod_poly_reverse(f_finv.value, f_f.value, f_f.value->length);
fmpz_mod_poly_inv_series_newton(f_finv.value, f_finv.value, f_f.value->length);
fmpz_mod_poly_mulmod_preinv(f_c.value, f_a.value, f_a.value, f_f.value, f_finv.value);
t = GetTime();
for (long i = 0; i < iter; i++)
fmpz_mod_poly_mulmod_preinv(f_c.value, f_a.value, f_a.value, f_f.value, f_finv.value);
t = GetTime()-t;
double FlintTime = t;
printf("%8.2f", FlintTime/NTLTime);
}
printf("\n");
}
}
int main()
{
_newntl_gmp_hack = 0;
long n, k;
n = 200;
k = 10*newNTL_ZZ_NBITS;
ZZ p;
RandomLen(p, k);
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i;
long iter;
n = 1024;
k = 1024;
RandomLen(p, k);
ZZ_p::init(p);
ZZ_pX j1, j2, j3;
random(j1, n);
random(j2, n);
mul(j3, j1, j2);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
FFTMul(j3, j1, j2);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((2/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
FFTMul(j3, j1, j2);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e12);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
int main()
{
#ifdef NTL_LONG_LONG
if (sizeof(NTL_LL_TYPE) < 2*sizeof(long)) {
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
SetSeed(ZZ(0));
long i, k;
k = 10*NTL_ZZ_NBITS;
for (i = 0; i < 10000; i++) {
ZZ a, b, c, d;
long da = RandomBnd(k);
long db = RandomBnd(k);
long dc = RandomBnd(k);
long dd = RandomBnd(k);
RandomLen(a, da); RandomLen(b, db); RandomLen(c, dc); RandomLen(d, dd);
if ((a + b)*(c + d) != c*a + d*a + c*b + d*b) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
for (i = 0; i < 10000; i++) {
ZZ a, b, c;
long da = RandomBnd(k);
long db = RandomBnd(k);
long dc = RandomBnd(k) + 2;
RandomLen(a, da); RandomLen(b, db); RandomLen(c, dc);
if ( ( a * b ) % c != ((a % c) * (b % c)) % c ) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
k = 1024;
ZZ x1, x2, x3;
double t;
long j;
RandomLen(x1, k);
RandomLen(x2, k);
long iter;
mul(x3, x1, x2);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 500; j++) mul(x3, x1, x2);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((3/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 500; j++) mul(x3, x1, x2);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e14);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
int main()
{
SetSeed(ZZ(0));
cerr << "This is NTL version " << NTL_VERSION << "\n";
cerr << "Hardware charactersitics:\n";
cerr << "NTL_BITS_PER_LONG = " << NTL_BITS_PER_LONG << "\n";
cerr << "NTL_ZZ_NBITS = " << NTL_ZZ_NBITS << "\n";
cerr << "NTL_SP_NBITS = " << NTL_SP_NBITS << "\n";
#ifdef NTL_HAVE_LL_TYPE
cerr << "NTL_HAVE_LL_TYPE\n";
#endif
#ifdef NTL_LONGDOUBLE_SP_MULMOD
cerr << "NTL_LONGDOUBLE_SP_MULMOD\n";
#endif
#ifdef NTL_LONGLONG_SP_MULMOD
cerr << "NTL_LONGLONG_SP_MULMOD\n";
#endif
cerr << "\n";
cerr << "Basic Configuration Options:\n";
#ifdef NTL_LEGACY_NO_NAMESPACE
cerr << "NTL_LEGACY_NO_NAMESPACE\n";
#endif
#ifdef NTL_LEGACY_INPUT_ERROR
cerr << "NTL_LEGACY_INPUT_ERROR\n";
#endif
#ifdef NTL_THREADS
cerr << "NTL_THREADS\n";
#endif
#ifdef NTL_EXCEPTIONS
cerr << "NTL_EXCEPTIONS\n";
#endif
#ifdef NTL_THREAD_BOOST
cerr << "NTL_THREAD_BOOST\n";
#endif
#ifdef NTL_LEGACY_SP_MULMOD
cout << "NTL_LEGACY_SP_MULMOD\n";
#endif
#ifdef NTL_DISABLE_LONGDOUBLE
cout << "NTL_DISABLE_LONGDOUBLE\n";
#endif
#ifdef NTL_DISABLE_LONGLONG
cout << "NTL_DISABLE_LONGLONG\n";
#endif
#ifdef NTL_MAXIMIZE_SP_NBITS
cout << "NTL_MAXIMIZE_SP_NBITS\n";
#endif
#ifdef NTL_GMP_LIP
cerr << "NTL_GMP_LIP\n";
#endif
#ifdef NTL_GF2X_LIB
cerr << "NTL_GF2X_LIB\n";
#endif
#ifdef NTL_PCLMUL
cerr << "NTL_PCLMUL\n";
#endif
#ifdef NTL_LONG_LONG_TYPE
cerr << "NTL_LONG_LONG_TYPE: ";
cerr << make_string(NTL_LONG_LONG_TYPE) << "\n";
#endif
#ifdef NTL_UNSIGNED_LONG_LONG_TYPE
cerr << "NTL_UNSIGNED_LONG_LONG_TYPE: ";
cerr << make_string(NTL_UNSIGNED_LONG_LONG_TYPE) << "\n";
#endif
#ifdef NTL_X86_FIX
cerr << "NTL_X86_FIX\n";
#endif
#ifdef NTL_NO_X86_FIX
cerr << "NTL_NO_X86_FIX\n";
#endif
#ifdef NTL_NO_INIT_TRANS
cerr << "NTL_NO_INIT_TRANS\n";
#endif
#ifdef NTL_CLEAN_INT
cerr << "NTL_CLEAN_INT\n";
#endif
#ifdef NTL_CLEAN_PTR
cerr << "NTL_CLEAN_PTR\n";
#endif
#ifdef NTL_RANGE_CHECK
cerr << "NTL_RANGE_CHECK\n";
#endif
cerr << "\n";
cerr << "Resolution of double-word types:\n";
cerr << make_string(NTL_LL_TYPE) << "\n";
cerr << make_string(NTL_ULL_TYPE) << "\n";
cerr << "\n";
cerr << "Performance Options:\n";
#ifdef NTL_LONG_LONG
cerr << "NTL_LONG_LONG\n";
#endif
#ifdef NTL_AVOID_FLOAT
cerr << "NTL_AVOID_FLOAT\n";
#endif
#ifdef NTL_SPMM_ULL
cerr << "NTL_SPMM_ULL\n";
#endif
#ifdef NTL_SPMM_ASM
cerr << "NTL_SPMM_ASM\n";
#endif
#ifdef NTL_AVOID_BRANCHING
cerr << "NTL_AVOID_BRANCHING\n";
#endif
#ifdef NTL_FFT_BIGTAB
cout << "NTL_FFT_BIGTAB\n";
#endif
#ifdef NTL_FFT_LAZYMUL
cout << "NTL_FFT_LAZYMUL\n";
#endif
#ifdef NTL_TBL_REM
cerr << "NTL_TBL_REM\n";
#endif
#ifdef NTL_TBL_REM_LL
cerr << "NTL_TBL_REM_LL\n";
#endif
#ifdef NTL_CRT_ALTCODE
cerr << "NTL_CRT_ALTCODE\n";
#endif
#ifdef NTL_CRT_ALTCODE_SMALL
cerr << "NTL_CRT_ALTCODE_SMALL\n";
#endif
#ifdef NTL_GF2X_ALTCODE
cerr << "NTL_GF2X_ALTCODE\n";
#endif
#ifdef NTL_GF2X_ALTCODE1
cerr << "NTL_GF2X_ALTCODE1\n";
#endif
#ifdef NTL_GF2X_NOINLINE
cerr << "NTL_GF2X_NOINLINE\n";
#endif
cerr << "\n\n";
cerr << "running tests";
long n, k, i;
n = 250;
k = 16000;
ZZ p;
for (i = 0; i < 15; i++) {
// cerr << n << "/" << k;
cerr << ".";
RandomLen(p, k);
ZZ_p::init(p);
ZZ_pX a, b, c, c1;
random(a, n);
random(b, n);
FFTMul(c, a, b);
//cerr << ZZ_pInfo->FFTInfo->NumPrimes;
c1 = conv<ZZ_pX>( KarMul( conv<ZZX>(a), conv<ZZX>(b) ) );
if (c1 != c) {
cerr << "ZZ_pX mul failed!\n";
return 1;
}
n = long(n * 1.35);
k = long(k / 1.414);
}
// small prime tests...I've made some changes in v5.3
// that should be checked on various platforms, so
// we might as well check them here.
if (SmallModulusTest(17, 1000)) {
cerr << "first SmallModulusTest failed!!\n";
return 1;
}
if (SmallModulusTest((1L << (NTL_SP_NBITS))-1, 1000)) {
cerr << "second SmallModulusTest failed!!\n";
return 1;
}
// Test gf2x code....
if (GF2X_test()) {
cerr << "GF2X test failed!\n";
return 1;
}
cerr << "OK\n";
ZZ x1, x2, x3, x4;
double t;
RandomLen(x1, 1024);
RandomBnd(x2, x1);
RandomBnd(x3, x1);
mul(x4, x2, x3);
t = GetTime();
for (i = 0; i < 100000; i++)
mul(x4, x2, x3);
t = GetTime()-t;
cerr << "time for 1024-bit mul: " << t*10 << "us";
cerr << "\n";
rem(x2, x4, x1);
t = GetTime();
for (i = 0; i < 100000; i++)
rem(x2, x4, x1);
t = GetTime()-t;
cerr << "time for 2048/1024-bit rem: " << t*10 << "us";
cerr << "\n";
GenPrime(p, 1024);
RandomBnd(x1, p);
if (IsZero(x1)) set(x1);
InvMod(x2, x1, p);
t = GetTime();
for (i = 0; i < 1000; i++)
InvMod(x2, x1, p);
t = GetTime()-t;
cerr << "time for 1024-bit modular inverse: " << t*1000 << "us";
cerr << "\n";
// test modulus switching
n = 1024;
k = 1024;
RandomLen(p, k);
ZZ_p::init(p);
if (!IsOdd(p)) p++;
ZZ_pX j1, j2, j3;
random(j1, n);
random(j2, n);
mul(j3, j1, j2);
t = GetTime();
for (i = 0; i < 200; i++) mul(j3, j1, j2);
t = GetTime()-t;
cerr << "time to multiply degree 1023 polynomials\n modulo a 1024-bit number: ";
cerr << (t/200) << "s";
cerr << "\n";
GF2X_time();
return 0;
}
int main()
{
#ifdef NTL_SPMM_ULL
if (sizeof(NTL_ULL_TYPE) < 2*sizeof(long)) {
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
long n, k;
n = 200;
k = 10*NTL_ZZ_NBITS;
ZZ p;
RandomLen(p, k);
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i, j;
long iter;
const int nprimes = 30;
const long L = 12;
const long N = 1L << L;
long r;
for (r = 0; r < nprimes; r++) UseFFTPrime(r);
vec_long aa[nprimes], AA[nprimes];
for (r = 0; r < nprimes; r++) {
aa[r].SetLength(N);
AA[r].SetLength(N);
for (i = 0; i < N; i++)
aa[r][i] = RandomBnd(GetFFTPrime(r));
FFTFwd(AA[r].elts(), aa[r].elts(), L, r);
FFTRev1(AA[r].elts(), AA[r].elts(), L, r);
}
iter = 1;
do {
t = GetTime();
for (j = 0; j < iter; j++) {
for (r = 0; r < nprimes; r++) {
long *AAp = AA[r].elts();
long *aap = aa[r].elts();
long q = GetFFTPrime(r);
mulmod_t qinv = GetFFTPrimeInv(r);
FFTFwd(AAp, aap, L, r);
FFTRev1(AAp, aap, L, r);
for (i = 0; i < N; i++) AAp[i] = NormalizedMulMod(AAp[i], aap[i], q, qinv);
}
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((1.5/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (j = 0; j < iter; j++) {
for (r = 0; r < nprimes; r++) {
long *AAp = AA[r].elts();
long *aap = aa[r].elts();
long q = GetFFTPrime(r);
mulmod_t qinv = GetFFTPrimeInv(r);
FFTFwd(AAp, aap, L, r);
FFTRev1(AAp, aap, L, r);
for (i = 0; i < N; i++) AAp[i] = NormalizedMulMod(AAp[i], aap[i], q, qinv);
}
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e13);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
int main()
{
cerr << "This is NTL version " << NTL_VERSION << "\n";
cerr << "Basic Configuration Options:\n";
#ifdef NTL_STD_CXX
cerr << "NTL_STD_CXX\n";
#endif
#ifdef NTL_PSTD_NNS
cerr << "NTL_PSTD_NNS\n";
#endif
#ifdef NTL_PSTD_NHF
cerr << "NTL_PSTD_NHF\n";
#endif
#ifdef NTL_PSTD_NTN
cerr << "NTL_PSTD_NTN\n";
#endif
#ifdef NTL_GMP_LIP
cerr << "NTL_GMP_LIP\n";
#endif
#ifdef NTL_GMP_HACK
cerr << "NTL_GMP_HACK\n";
#endif
#ifdef NTL_GF2X_LIB
cerr << "NTL_GF2X_LIB\n";
#endif
#ifdef NTL_LONG_LONG_TYPE
cerr << "NTL_LONG_LONG_TYPE: ";
cerr << make_string(NTL_LONG_LONG_TYPE) << "\n";
#endif
#ifdef NTL_UNSIGNED_LONG_LONG_TYPE
cerr << "NTL_UNSIGNED_LONG_LONG_TYPE: ";
cerr << make_string(NTL_UNSIGNED_LONG_LONG_TYPE) << "\n";
#endif
#ifdef NTL_CXX_ONLY
cerr << "NTL_CXX_ONLY\n";
#endif
#ifdef NTL_X86_FIX
cerr << "NTL_X86_FIX\n";
#endif
#ifdef NTL_NO_X86_FIX
cerr << "NTL_NO_X86_FIX\n";
#endif
#ifdef NTL_NO_INIT_TRANS
cerr << "NTL_NO_INIT_TRANS\n";
#endif
#ifdef NTL_CLEAN_INT
cerr << "NTL_CLEAN_INT\n";
#endif
#ifdef NTL_CLEAN_PTR
cerr << "NTL_CLEAN_PTR\n";
#endif
#ifdef NTL_RANGE_CHECK
cerr << "NTL_RANGE_CHECK\n";
#endif
cerr << "\n";
cerr << "Resolution of double-word types:\n";
cerr << make_string(NTL_LL_TYPE) << "\n";
cerr << make_string(NTL_ULL_TYPE) << "\n";
cerr << "\n";
cerr << "Performance Options:\n";
#ifdef NTL_LONG_LONG
cerr << "NTL_LONG_LONG\n";
#endif
#ifdef NTL_AVOID_FLOAT
cerr << "NTL_AVOID_FLOAT\n";
#endif
#ifdef NTL_SPMM_UL
cerr << "NTL_SPMM_UL\n";
#endif
#ifdef NTL_SPMM_ULL
cerr << "NTL_SPMM_ULL\n";
#endif
#ifdef NTL_SPMM_ASM
cerr << "NTL_SPMM_ASM\n";
#endif
#ifdef NTL_AVOID_BRANCHING
cerr << "NTL_AVOID_BRANCHING\n";
#endif
#ifdef NTL_TBL_REM
cerr << "NTL_TBL_REM\n";
#endif
#ifdef NTL_GF2X_ALTCODE
cerr << "NTL_GF2X_ALTCODE\n";
#endif
#ifdef NTL_GF2X_ALTCODE1
cerr << "NTL_GF2X_ALTCODE1\n";
#endif
#ifdef NTL_GF2X_NOINLINE
cerr << "NTL_GF2X_NOINLINE\n";
#endif
cerr << "\n\n";
if (_ntl_gmp_hack)
cerr << "using GMP hack\n\n";
cerr << "running tests...";
long n, k;
n = 200;
k = 10*NTL_ZZ_NBITS;
ZZ p;
GenPrime(p, k);
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
// SetCoeff(f, n); // Sets coefficient of X^n to 1
ZZ_p lc;
do {
random(lc);
} while (IsZero(lc));
SetCoeff(f, n, lc);
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
cerr << "r1 != r2!!\n";
return 1;
}
else if (r1 != r3) {
cerr << "r1 != r3!!\n";
return 1;
}
// small prime tests...I've made some changes in v5.3
// that should be checked on various platforms, so
// we might as well check them here.
if (SmallModulusTest(17, 1000)) {
cerr << "first SmallModulusTest failed!!\n";
return 1;
}
if (SmallModulusTest((1L << (NTL_SP_NBITS))-1, 1000)) {
cerr << "second SmallModulusTest failed!!\n";
return 1;
}
// Test gf2x code....
if (GF2X_test()) {
cerr << "GF2X test failed!\n";
return 1;
}
cerr << "OK\n";
ZZ x1, x2, x3, x4;
double t;
long i;
RandomLen(x1, 1024);
RandomBnd(x2, x1);
RandomBnd(x3, x1);
mul(x4, x2, x3);
t = GetTime();
for (i = 0; i < 100000; i++)
mul(x4, x2, x3);
t = GetTime()-t;
cerr << "time for 1024-bit mul: " << t*10 << "us";
if (_ntl_gmp_hack) {
_ntl_gmp_hack = 0;
mul(x4, x2, x3);
t = GetTime();
for (i = 0; i < 100000; i++)
mul(x4, x2, x3);
t = GetTime()-t;
cerr << " (" << (t*10) << "us without GMP)";
_ntl_gmp_hack = 1;
}
cerr << "\n";
rem(x2, x4, x1);
t = GetTime();
for (i = 0; i < 100000; i++)
rem(x2, x4, x1);
t = GetTime()-t;
cerr << "time for 2048/1024-bit rem: " << t*10 << "us";
if (_ntl_gmp_hack) {
_ntl_gmp_hack = 0;
rem(x2, x4, x1);
t = GetTime();
for (i = 0; i < 100000; i++)
rem(x2, x4, x1);
t = GetTime()-t;
cerr << " (" << (t*10) << "us without GMP)";
_ntl_gmp_hack = 1;
}
cerr << "\n";
GenPrime(p, 1024);
RandomBnd(x1, p);
if (IsZero(x1)) set(x1);
InvMod(x2, x1, p);
t = GetTime();
for (i = 0; i < 1000; i++)
InvMod(x2, x1, p);
t = GetTime()-t;
cerr << "time for 1024-bit modular inverse: " << t*1000 << "us";
if (_ntl_gmp_hack) {
_ntl_gmp_hack = 0;
InvMod(x2, x1, p);
t = GetTime();
for (i = 0; i < 1000; i++)
InvMod(x2, x1, p);
t = GetTime()-t;
cerr << " (" << (t*1000) << "us without GMP)";
_ntl_gmp_hack = 1;
}
cerr << "\n";
// test modulus switching
n = 1024;
k = 1024;
RandomLen(p, k);
ZZ_p::init(p);
ZZ_pInfo->check();
ZZ_pX j1, j2, j3;
random(j1, n);
random(j2, n);
t = GetTime();
for (i = 0; i < 20; i++) mul(j3, j1, j2);
t = GetTime()-t;
cerr << "time to multiply degree 1023 polynomials\n modulo a 1024-bit number: ";
cerr << (t/20) << "s";
if (_ntl_gmp_hack) {
_ntl_gmp_hack = 0;
ZZ_p::init(p);
ZZ_pInfo->check();
t = GetTime();
for (i = 0; i < 20; i++) mul(j3, j1, j2);
t = GetTime()-t;
cerr << " (" << (t/20) << "s without GMP)";
_ntl_gmp_hack = 1;
}
cerr << "\n";
GF2X_time();
return 0;
}
int main()
{
setbuf(stdout, NULL);
for (long l = 5; l <= 60; l += 5) {
// for (long n = 1024; n <= 65536; n *= 2) {
for (long idx = 0; idx < 13; idx ++) {
long n = 1024*(1L << idx/2);
if (idx & 1) n += n/2;
SetSeed((ZZ(l) << 64) + ZZ(n));
long p;
RandomLen(p, l);
if (p % 2 == 0) p++;
zz_p::init(p);
zz_pX a, b, c, f;
random(a, n);
random(b, n);
random(f, n);
SetCoeff(f, n);
zz_pXModulus F(f);
zz_pXMultiplier B(b, F);
double t;
MulMod(c, a, B, F);
long iter = 1;
do {
t = GetTime();
for (long i = 0; i < iter; i++) MulMod(c, a, B, F);
t = GetTime() - t;
iter *= 2;
} while (t < 3);
iter /= 2;
t = GetTime();
for (long i = 0; i < iter; i++) MulMod(c, a, B, F);
t = GetTime()-t;
double NTLTime = t;
Flintzz_pX f_a(a), f_b(b), f_c, f_f(f), f_finv;
nmod_poly_reverse(f_finv.value, f_f.value, f_f.value->length);
nmod_poly_inv_series_newton(f_finv.value, f_finv.value, f_f.value->length);
nmod_poly_mulmod_preinv(f_c.value, f_a.value, f_b.value, f_f.value, f_finv.value);
t = GetTime();
for (long i = 0; i < iter; i++)
nmod_poly_mulmod_preinv(f_c.value, f_a.value, f_b.value, f_f.value, f_finv.value);
t = GetTime()-t;
double FlintTime = t;
printf("%8.2f", FlintTime/NTLTime);
}
printf("\n");
}
}
int main()
{
#if (defined(NTL_CRT_ALTCODE) && !(defined(NTL_HAVE_LL_TYPE) && NTL_ZZ_NBITS == NTL_BITS_PER_LONG))
{
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
SetSeed(ZZ(0));
long n, k;
n = 1024;
k = 30*NTL_SP_NBITS;
ZZ p;
RandomLen(p, k);
if (!IsOdd(p)) p++;
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i;
long iter;
ZZ_pX a, b, c;
random(a, n);
random(b, n);
long da = deg(a);
long db = deg(b);
long dc = da + db;
long l = NextPowerOfTwo(dc+1);
FFTRep arep, brep, crep;
ToFFTRep(arep, a, l, 0, da);
ToFFTRep(brep, b, l, 0, db);
mul(crep, arep, brep);
ZZ_pXModRep modrep;
FromFFTRep(modrep, crep);
FromZZ_pXModRep(c, modrep, 0, dc);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
FromZZ_pXModRep(c, modrep, 0, dc);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((3/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
FromZZ_pXModRep(c, modrep, 0, dc);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e12);
// The following is just to test some tuning Wizard logic --
// be sure to get rid of this!!
#if (defined(NTL_CRT_ALTCODE))
// t *= 1.12;
#endif
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
