NTL_START_IMPL
long IterIrredTest(const GF2X& f)
{
long df = deg(f);
if (df <= 0) return 0;
if (df == 1) return 1;
GF2XModulus F;
build(F, f);
GF2X h;
SetX(h);
SqrMod(h, h, F);
long i, d, limit, limit_sqr;
GF2X g, X, t, prod;
SetX(X);
i = 0;
g = h;
d = 1;
limit = 2;
limit_sqr = limit*limit;
set(prod);
while (2*d <= df) {
add(t, g, X);
MulMod(prod, prod, t, F);
i++;
if (i == limit_sqr) {
GCD(t, f, prod);
if (!IsOne(t)) return 0;
set(prod);
limit++;
limit_sqr = limit*limit;
i = 0;
}
d = d + 1;
if (2*d <= deg(f)) {
SqrMod(g, g, F);
}
}
if (i > 0) {
GCD(t, f, prod);
if (!IsOne(t)) return 0;
}
return 1;
}
void ComposeFrobeniusMap(GF2EX& y, const GF2EXModulus& F)
{
long d = GF2E::degree();
long n = deg(F);
long i;
i = 1;
while (i <= d) i = i << 1;
i = i >> 1;
GF2EX z(INIT_SIZE, n), z1(INIT_SIZE, n);
i = i >> 1;
long m = 1;
if (n == 2) {
SetX(z);
SqrMod(z, z, F);
}
else {
while (i) {
long m1 = 2*m;
if (i & d) m1++;
if (m1 >= NTL_BITS_PER_LONG-1 || (1L << m1) >= n) break;
m = m1;
i = i >> 1;
}
clear(z);
SetCoeff(z, 1L << m);
}
while (i) {
z1 = z;
long j, k, dz;
dz = deg(z);
for (j = 0; j <= dz; j++)
for (k = 0; k < m; k++)
sqr(z1.rep[j], z1.rep[j]);
CompMod(z, z1, z, F);
m = 2*m;
if (d & i) {
SqrMod(z, z, F);
m++;
}
i = i >> 1;
}
y = z;
}
double XFSpectrumDataSerie::Rrr(const int nF0, const int nF1)
{
if(nF0 == nF1)
return dB(SqrMod(m_pfcpxGrr[nF0]));
double dbSum = 0.0;
for(int i = nF0; i < nF1; i++)
{
if(i < int(m_unSpectrumLength))
dbSum += SqrMod(m_pfcpxGrr[i]);
}
return dB(dbSum/(nF1 - nF0));
}
void PlainFrobeniusMap(GF2EX& h, const GF2EXModulus& F)
{
GF2EX res;
SetX(res);
long i;
for (i = 0; i < GF2E::degree(); i++)
SqrMod(res, res, F);
h = res;
}
static
void TraceMap(GF2X& w, const GF2X& a, long d, const GF2XModulus& F)
{
GF2X y, z;
y = a;
z = a;
long i;
for (i = 1; i < d; i++) {
SqrMod(z, z, F);
add(y, y, z);
}
w = y;
}
static
void AbsTraceMap(ZZ_pEX& h, const ZZ_pEX& a, const ZZ_pEXModulus& F)
{
ZZ_pEX res, tmp;
long k = NumBits(ZZ_pE::cardinality())-1;
res = a;
tmp = a;
long i;
for (i = 0; i < k-1; i++) {
SqrMod(tmp, tmp, F);
add(res, res, tmp);
}
h = res;
}
static
void TraceMap(GF2EX& h, const GF2EX& a, const GF2EXModulus& F)
// one could consider making a version based on modular composition,
// as in ComposeFrobeniusMap...
{
GF2EX res, tmp;
res = a;
tmp = a;
long i;
for (i = 0; i < GF2E::degree()-1; i++) {
SqrMod(tmp, tmp, F);
add(res, res, tmp);
}
h = res;
}
/* Quickly find factor of n in the case where n is a prime power (and not
* a power of 2). n>2, odd. Returns q, a factor of n, or 1 in case of
* failure.
*/
void PrimePowerTest(ZZ& q, const ZZ& n) {
// n-1 == 2^k * m, m odd
ZZ n1,m;
sub(n1,n,1);
m=n1;
long k = MakeOdd(m);
set(q);
ZZ z;
conv(z,2);
PowerMod(z,z,m,n);
do {
if (IsOne(z) || z==n1) return;
SqrMod(z,z,n);
} while (--k>0);
if (IsOne(z)) return;
z*=2;
z-=2;
GCD(q,z,n);
if (q==0 || q==n)
set(q);
}
void DDF(vec_pair_GF2X_long& factors, const GF2X& ff, long verbose)
{
GF2X f = ff;
if (IsZero(f)) Error("DDF: bad args");
factors.SetLength(0);
if (deg(f) == 0)
return;
if (deg(f) == 1) {
AddFactor(factors, f, 1, verbose);
return;
}
long GCDTableSize = GF2X_BlockingFactor;
GF2XModulus F;
build(F, f);
long i, d, limit, old_n;
GF2X g, X;
vec_GF2X tbl(INIT_SIZE, GCDTableSize);
SetX(X);
i = 0;
SqrMod(g, X, F);
d = 1;
limit = GCDTableSize;
while (2*d <= deg(f)) {
old_n = deg(f);
add(tbl[i], g, X);
i++;
if (i == limit) {
ProcessTable(f, factors, F, i, tbl, d, verbose);
i = 0;
}
d = d + 1;
if (2*d <= deg(f)) {
// we need to go further
if (deg(f) < old_n) {
// f has changed
build(F, f);
rem(g, g, F);
}
SqrMod(g, g, F);
}
}
ProcessTable(f, factors, F, i, tbl, d-1, verbose);
if (!IsOne(f)) AddFactor(factors, f, deg(f), verbose);
}
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(int argc, char *argv[])
{
argmap_t argmap;
argmap["m"] = "0";
argmap["p"] = "2";
argmap["r"] = "1";
if (!parseArgs(argc, argv, argmap)) usage();
unsigned long m = atoi(argmap["m"]);
if (!m) usage();
unsigned long p = atoi(argmap["p"]);
unsigned long r = atoi(argmap["r"]);
cout << "m = " << m << ", p = " << p << ", r = " << r << endl;
vector<long> f;
factorize(f,m);
cout << "factoring "<<m<<" gives [";
for (unsigned long i=0; i<f.size(); i++)
cout << f[i] << " ";
cout << "]\n";
PAlgebra al(m, p);
al.printout();
cout << "\n";
PAlgebraMod almod(al, r);
almod.genMaskTable();
FHEcontext context(m, p, r);
buildModChain(context, 5, 2);
stringstream s1;
writeContextBase(s1, context);
s1 << context;
string s2 = s1.str();
cout << s2 << endl;
stringstream s3(s2);
unsigned long m1, p1, r1;
readContextBase(s3, m1, p1, r1);
FHEcontext c1(m1, p1, r1);
s3 >> c1;
if (context == c1)
cout << "equal\n";
else
cout << "not equal\n";
return 0;
#if 0
PAlgebraModTwo al2(al);
PAlgebraMod2r al2r(r,al2);
if (false) {
long nslots = al.NSlots();
long ngens = al.numOfGens();
for (long i = 0; i < nslots; i++) {
const int* v = al.dLog(al.ith_rep(i));
cout << i << " ";
for (long j = 0; j < ngens; j++)
cout << v[j] << " ";
cout << "\n";
}
return 0;
}
// GF2X::HexOutput = 1; // compact hexadecimal printout
// cout << "Phi_m(X) = " << al.PhimX() << endl;
// vec_GF2X Fs = al2.Factors();
// cout << "Factors = " << Fs << endl;
// GF2X Q = Fs[0];
// for (long i=1; i<Fs.length(); i++) Q *= Fs[i];
// cout << "mult of factors = " << Q << endl;
GF2X G; // G is the AES polynomial, G(X)= X^8 +X^4 +X^3 +X +1
SetCoeff(G,8); SetCoeff(G,4); SetCoeff(G,3); SetCoeff(G,1); SetCoeff(G,0);
// GF2X G; SetCoeff(G,4); SetCoeff(G,1); SetCoeff(G,0); // X^4 +X +1
// cout << "G = " << G << ", deg(G)=" << deg(G) << endl;
vector<GF2X> maps;
al2.mapToSlots(maps, G);
// cout << "maps = [";
// for (unsigned long i=0; i<maps.size(); i++)
// cout << maps[i] << " ";
// cout << "]\n";
GF2X X; SetX(X); // The polynomial X
GF2X ptxt; // plaintext has X in all the slots
cout << "embedding X in plaintext slots... ";
al2.embedInAllSlots(ptxt, X, maps);
cout << "done\n";
// cout << "ptxt = " << ptxt << endl;
// Debugging printout: p modulo all the factors
// vector<GF2X> crt;
// al2.CRT_decompose(crt,ptxt);
// cout << "ptxt mod factors = [";
// for (unsigned long i=0; i<crt.size(); i++) cout << crt[i] << " ";
// cout << "]\n";
// Decode the plaintext back to a vector of elements,
// and check that they are all equal to X
vector<GF2X> alphas;
cout << "decoding plaintext slots... ";
al2.decodePlaintext(alphas, ptxt, G, maps);
cout << "done\n";
// cout << "alphas = [";
// for (unsigned long i=0; i<alphas.size(); i++)
// cout << alphas[i] << " ";
// cout << "]\n";
cout << "comparing " << alphas.size() << " plaintext slots to X... ";
for (unsigned long i=0; i<alphas.size(); i++) if (alphas[i] != X) {
cout << "\n alphas["<<i<<"] = "<<alphas[i]<<" != X\n\n";
exit(0);
}
cout << "all tests completed successfully\n\n";
// encode and decode random polynomials
for (unsigned long i=0; i<alphas.size(); i++)
random(alphas[i], 8); // random degree-7 polynomial mod 2
cout << "embedding random GF(2^8) elements in plaintext slots... ";
al2.embedInSlots(ptxt, alphas, maps);
cout << "done\n";
// Compute p^2 mod Phi_m(X) and also p(X^2) mod Phi_m(X) and
// verify that they both decode to a vector of X^2 in all the slots
cout << "squaring and decoding plaintext slots... ";
X *= X; // X^2
// GF2X ptxt2;
// SqrMod(ptxt2,ptxt,al2.PhimXMod()); // ptxt2 = ptxt^2 mod Phi_m(X)
CompMod(ptxt, ptxt, X, al2.PhimXMod()); // ptxt = ptxt(X^2) mod Phi_m(X)
// // sanity chack: these should be the same mod 2 (but not mod 2^r)
// if (ptxt != ptxt2) cout << "ptxt^2 != ptxt(X^2) mod Phi_m(X)\n";
vector<GF2X> betas;
al2.decodePlaintext(betas, ptxt, G, maps);
cout << "done\n";
if (alphas.size() != betas.size()) Error("wrong number of slots decoded");
cout << "comparing decoded plaintext slots... ";
for (unsigned long i=0; i<alphas.size(); i++) {
SqrMod(alphas[i],alphas[i],G); // should get alpha[i]^2 mod G
if (alphas[i] != betas[i]) {
cout << "\n alphas["<<i<<"] = "<<alphas[i]
<<" != " << "betas["<<i<<"] = " << betas[i] << "\n\n";
exit(0);
}
}
cout << "all tests completed successfully\n\n";
// return 0;
al2r.restoreContext();
vector<zz_pX> maps1;
zz_pX X1; SetX(X1);
cerr << "HERE1\n";
al2r.mapToSlots(maps1, X1);
cerr << "HERE1a\n";
vector<zz_pX> alphas1;
alphas1.resize(maps.size());
for (long i = 0; i < lsize(alphas1); i++)
random(alphas1[i], 1);
zz_pX ptxt1;
cerr << "HERE2\n";
al2r.embedInSlots(ptxt1, alphas1, maps1);
cerr << "HERE3\n";
vector<zz_pX> betas1;
al2r.decodePlaintext(betas1, ptxt1, X1, maps1);
assert(alphas1 == betas1);
return 0;
#endif
}
