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;
}
bool Matrix4x4::isIdentity() const
{
bool result = false;
if( IsOne(m_Internal->matrix[0][0]) && IsZero(m_Internal->matrix[1][0]) && IsZero(m_Internal->matrix[2][0]) && IsZero(m_Internal->matrix[3][0]) &&
IsZero(m_Internal->matrix[0][0]) && IsOne(m_Internal->matrix[1][0]) && IsZero(m_Internal->matrix[2][0]) && IsZero(m_Internal->matrix[3][0]) &&
IsZero(m_Internal->matrix[0][0]) && IsZero(m_Internal->matrix[1][0]) && IsOne(m_Internal->matrix[2][0]) && IsZero(m_Internal->matrix[3][0]) &&
IsZero(m_Internal->matrix[0][0]) && IsZero(m_Internal->matrix[1][0]) && IsZero(m_Internal->matrix[2][0]) && IsOne(m_Internal->matrix[3][0]))
{
result = true;
}
return result;
}
Boolean RTCResult(int Iter, double rNorm, double bNorm, IterIdType IterId)
/* get result of RTC */
{
Boolean Result;
if (LASResult() == LASOK) {
if (rNorm < RTCEps * bNorm || (IsZero(bNorm) && IsOne(1.0 + rNorm)))
Result = True;
else
Result = False;
LastNoIter = Iter;
if (!IsZero(bNorm))
LastAcc = rNorm / bNorm;
else
LastAcc = 1.0;
if (RTCAuxProc != NULL)
(*RTCAuxProc)(Iter, rNorm, bNorm, IterId);
} else {
Result = True;
}
return(Result);
}
long operator==(const GF2X& a, long b)
{
if (b & 1)
return IsOne(a);
else
return IsZero(a);
}
long operator==(const GF2X& a, GF2 b)
{
if (b == 1)
return IsOne(a);
else
return IsZero(a);
}
// recursive factoring (precondition: n composite)
// currently only uses ECM
void factor_r(vec_pair_ZZ_long& factors, const ZZ& _n,
const ZZ& bnd, double failure_prob, bool verbose) {
ZZ q;
ZZ n(_n);
do {
// attempt to factor n
if (bnd>0)
ECM(q,n,bnd,failure_prob,verbose);
else
ECM(q,n,ZZ::zero(),0,verbose);
if (IsOne(q)) {
// give up
addFactor(factors,n);
return;
}
// compute other factor
div(n,n,q);
if (n<q) swap(n,q);
// q is small factor, n is large factor
if (ProbPrime_notd(q))
addFactor(factors,q);
else
factor_r(factors,q,bnd,failure_prob,verbose);
// check if n is still composite
if (ProbPrime_notd(n)) {
addFactor(factors,n);
return;
}
} while (true);
}
// trial division primitive
void TrialDivision(vec_pair_ZZ_long& factors, ZZ& q, const ZZ& n, long bnd) {
factors.SetLength(0);
if (&q!=&n) q=n;
if (bnd==0) {
bnd=10000; // should probably be higher
}
PrimeSeq s;
ZZ d;
for (long p=s.next(); (p>0 && p<=bnd); p=s.next()) {
if (DivRem(d,q,p)==0) {
long e=1;
q=d;
while (DivRem(d,q,p)==0) {
++e;
q=d;
}
addFactor(factors,to_ZZ(p),e);
if (IsOne(q))
return;
}
if (d<=p) {
// q must be prime
addFactor(factors,q);
set(q);
return;
}
}
}
void CanZass(vec_pair_ZZ_pEX_long& factors, const ZZ_pEX& f, long verbose)
{
if (!IsOne(LeadCoeff(f)))
LogicError("CanZass: bad args");
double t;
vec_pair_ZZ_pEX_long sfd;
vec_ZZ_pEX x;
if (verbose) { cerr << "square-free decomposition..."; t = GetTime(); }
SquareFreeDecomp(sfd, f);
if (verbose) cerr << (GetTime()-t) << "\n";
factors.SetLength(0);
long i, j;
for (i = 0; i < sfd.length(); i++) {
if (verbose) {
cerr << "factoring multiplicity " << sfd[i].b
<< ", deg = " << deg(sfd[i].a) << "\n";
}
SFCanZass(x, sfd[i].a, verbose);
for (j = 0; j < x.length(); j++)
append(factors, cons(x[j], sfd[i].b));
}
}
void ECM(ZZ& q, const ZZ& N, long ncurves, long B1, long B2, long D,
bool verbose) {
// initialize ZZ_p
ZZ_pBak bak;
bak.save();
ZZ_p::init(N);
PrimeSeq seq;
for (long i=0; i<ncurves; ++i) {
if (verbose) {
if (ncurves<NTL_MAX_LONG)
std::cout<<"ECM: "<<NumBits(N)<<" bits; "
<<i<<"/"<<ncurves<<" curves\r"<<std::flush;
else
std::cout<<"ECM: "<<NumBits(N)<<" bits; "
<<i<<" curves\r"<<std::flush;
}
// try to find a factor
ECM_one_curve(q,seq,B1,B2,D);
if (!IsOne(q)) {
if (verbose) {
std::cout<<"ECM: "<<NumBits(N)<<" bits; "
<<(i+1)<<" curves; found "<<q<<" "<<std::endl;
}
return;
}
}
if (verbose)
std::cout<<"ECM: "<<NumBits(N)<<" bits; FAILED! "<<std::endl;
set(q);
}
void FindRoot(GF2E& root, const GF2EX& ff)
// finds a root of ff.
// assumes that ff is monic and splits into distinct linear factors
{
GF2EXModulus F;
GF2EX h, h1, f;
GF2E r;
f = ff;
if (!IsOne(LeadCoeff(f)))
Error("FindRoot: bad args");
if (deg(f) == 0)
Error("FindRoot: bad args");
while (deg(f) > 1) {
build(F, f);
random(r);
clear(h);
SetCoeff(h, 1, r);
TraceMap(h, h, F);
GCD(h, h, f);
if (deg(h) > 0 && deg(h) < deg(f)) {
if (deg(h) > deg(f)/2)
div(f, f, h);
else
f = h;
}
}
root = ConstTerm(f);
}
NTL_START_IMPL
void SquareFreeDecomp(vec_pair_ZZ_pX_long& u, const ZZ_pX& ff)
{
ZZ_pX f = ff;
if (!IsOne(LeadCoeff(f)))
Error("SquareFreeDecomp: bad args");
ZZ_pX r, t, v, tmp1;
long m, j, finished, done;
u.SetLength(0);
if (deg(f) == 0)
return;
m = 1;
finished = 0;
do {
j = 1;
diff(tmp1, f);
GCD(r, f, tmp1);
div(t, f, r);
if (deg(t) > 0) {
done = 0;
do {
GCD(v, r, t);
div(tmp1, t, v);
if (deg(tmp1) > 0) append(u, cons(tmp1, j*m));
if (deg(v) > 0) {
div(r, r, v);
t = v;
j++;
}
else
done = 1;
} while (!done);
if (deg(r) == 0) finished = 1;
}
if (!finished) {
/* r is a p-th power */
long p, k, d;
conv(p, ZZ_p::modulus());
d = deg(r)/p;
f.rep.SetLength(d+1);
for (k = 0; k <= d; k++)
f.rep[k] = r.rep[k*p];
m = m*p;
}
} while (!finished);
}
Boolean Q_KerDefined(QMatrix *Q)
/* returns True if Q is singular and the null space has been defined
otherwise False */
{
Boolean KerDefined;
if (LASResult() == LASOK) {
if ((Q->UnitRightKer || Q->RightKerCmp != NULL) && !IsZero(Q->MultiplD)
&& IsOne(Q->MultiplU / Q->MultiplD) && IsOne(Q->MultiplL / Q->MultiplD))
KerDefined = True;
else
KerDefined = False;
} else {
KerDefined = (Boolean)0;
}
return(KerDefined);
}
void PolyRingBase::myMonic(RawPtr rawmonic, ConstRawPtr rawf) const
{
if (myIsZero(rawf)) // or CoCoA_ASSERT???
CoCoA_ERROR(ERR::ZeroRingElem,"PolyRingBase::myMonic");
RingElem ans = RingElemAlias(ring(this), rawf);
if (!IsOne(myLC(rawf)) && !myDivByCoeff(raw(ans), raw(myLC(rawf))))
CoCoA_ERROR(ERR::BadQuot, "PolyRingBase::myDiv");
mySwap(rawmonic, raw(ans));
}
long operator==(const RR& a, double b)
{
if (b == 0) return IsZero(a);
if (b == 1) return IsOne(a);
NTL_TLS_LOCAL(RR, B);
B = b;
return a == B;
}
long operator==(const RR& a, double b)
{
if (b == 0) return IsZero(a);
if (b == 1) return IsOne(a);
static RR B;
B = b;
return a == B;
}
bool_t add(divisor& x, const divisor& a, const divisor& b)
// This subroutine wraps other functions that does the actual
// divisor arithmetic. It checks the validity of input divisors
// so that other subroutines it calls do not need to do so.
{
bool_t OK = TRUE;
/* Reduce overhead of checking with NDEBUG flag */
assert(OK = OK && a.is_valid_divisor() && b.is_valid_divisor());
if (deg(a.get_upoly()) == genus && deg(b.get_upoly()) == genus) {
if (a == - b) {
x.set_unit();
OK = TRUE;
return OK;
}
if (a != b && IsOne(GCD(a.get_upoly(), b.get_upoly()))) {
// Addition
OK = OK && add_diff(x, a, b);
return OK;
} else if (a == b && IsOne(GCD(a.get_curve().get_h() +
2*a.get_vpoly(), a.get_upoly())) ) {
// Doubling
// Exclude the case when one point of the divisor is equal to
// its opposite
OK = OK && doubling(x, a);
return OK;
}
}
// Call add_cantor() to handle other cases
OK = OK && add_cantor(x, a, b);
return OK;
}
void FindRoots(vec_ZZ_pE& x, const ZZ_pEX& ff)
{
ZZ_pEX f = ff;
if (!IsOne(LeadCoeff(f)))
LogicError("FindRoots: bad args");
x.SetMaxLength(deg(f));
x.SetLength(0);
RecFindRoots(x, f);
}
void FindRoots(vec_GF2E& x, const GF2EX& ff)
{
GF2EX f = ff;
if (!IsOne(LeadCoeff(f)))
Error("FindRoots: bad args");
x.SetMaxLength(deg(f));
x.SetLength(0);
RecFindRoots(x, f);
}
void SquareFreeDecomp(vec_pair_GF2EX_long& u, const GF2EX& ff)
{
GF2EX f = ff;
if (!IsOne(LeadCoeff(f)))
Error("SquareFreeDecomp: bad args");
GF2EX r, t, v, tmp1;
long m, j, finished, done;
u.SetLength(0);
if (deg(f) == 0)
return;
m = 1;
finished = 0;
do {
j = 1;
diff(tmp1, f);
GCD(r, f, tmp1);
div(t, f, r);
if (deg(t) > 0) {
done = 0;
do {
GCD(v, r, t);
div(tmp1, t, v);
if (deg(tmp1) > 0) append(u, cons(tmp1, j*m));
if (deg(v) > 0) {
div(r, r, v);
t = v;
j++;
}
else
done = 1;
} while (!done);
if (deg(r) == 0) finished = 1;
}
if (!finished) {
/* r is a square */
long k, d;
d = deg(r)/2;
f.rep.SetLength(d+1);
for (k = 0; k <= d; k++)
IterSqr(f.rep[k], r.rep[k*2], GF2E::degree()-1);
m = m*2;
}
} while (!finished);
}
static
long IrredBaseCase(const ZZ_pEX& h, long q, long a, const ZZ_pEXModulus& F)
{
long e;
ZZ_pEX X, s, d;
e = power(q, a-1);
PowerCompose(s, h, e, F);
SetX(X);
sub(s, s, X);
GCD(d, F.f, s);
return IsOne(d);
}
void MakeMonic(zz_pX& x)
{
if (IsZero(x))
return;
if (IsOne(LeadCoeff(x)))
return;
zz_p t;
inv(t, LeadCoeff(x));
mul(x, x, t);
}
/* 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 DenseMatImpl::myColMul(long j, ConstRefRingElem c)
{
const char* const FnName = "DenseMatImpl::myColMul";
myCheckColIndex(j, FnName);
if (owner(c) != myR)
CoCoA_ERROR(ERR::MixedRings, FnName);
if (IsOne(c)) return;
vector<RingElem> ans;
ans.resize(myNumRows(), zero(myR));
for (long i = 0; i < myNumRows(); ++i)
myR->myMul(raw(ans[i]), raw(c), myEntries[i][j]);
// Answer successfully computed in ans, swap it into the i-th row.
for (long i = 0; i < myNumRows(); ++i)
myR->mySwap(myEntries[i][j], raw(ans[i]));
}
void
make_rsa_key(rsa_pub &pub, rsa_priv &priv, long bits, ZZ& e)
{
pub.e = e;
do
{
GenPrime(priv.p, bits/2);
}
while (!IsOne(GCD(priv.p-1, pub.e)));
do
{
GenPrime(priv.q, bits/2);
}
while (!IsOne(GCD(priv.q-1, pub.e)));
pub.N = priv.p * priv.q;
priv.d = InvMod(pub.e, (priv.p-1)*(priv.q-1));
rem(priv.dp1, priv.d, priv.p-1);
rem(priv.dq1, priv.d, priv.q-1);
}
/*!
@function IsOrthogonalMatrix
@abstract Test whether a matrix is orthogonal, i.e., length-preserving,
i.e., either a rigid motion or a reflection.
*/
static bool IsOrthogonalMatrix( const TQ3Matrix4x4& inMtx )
{
// First check for usual last column.
bool isOrtho = IsOne( inMtx.value[3][3] ) &&
IsZero( inMtx.value[0][3] ) &&
IsZero( inMtx.value[1][3] ) &&
IsZero( inMtx.value[2][3] );
if (isOrtho)
{
// Then check that upper 3x3 is orthogonal.
const TQ3Vector3D* row1 = (const TQ3Vector3D*) &inMtx.value[0];
const TQ3Vector3D* row2 = (const TQ3Vector3D*) &inMtx.value[1];
const TQ3Vector3D* row3 = (const TQ3Vector3D*) &inMtx.value[2];
isOrtho = IsOne( Q3FastVector3D_LengthSquared( row1 ) ) &&
IsOne( Q3FastVector3D_LengthSquared( row2 ) ) &&
IsOne( Q3FastVector3D_LengthSquared( row3 ) ) &&
IsZero( Q3FastVector3D_Dot( row1, row2 ) ) &&
IsZero( Q3FastVector3D_Dot( row1, row3 ) ) &&
IsZero( Q3FastVector3D_Dot( row2, row3 ) );
}
return isOrtho;
}
long IsIdent(const mat_ZZ& A, long n)
{
if (A.NumRows() != n || A.NumCols() != n)
return 0;
long i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i != j) {
if (!IsZero(A(i, j))) return 0;
}
else {
if (!IsOne(A(i, j))) return 0;
}
return 1;
}
void EDF(vec_ZZ_pEX& factors, const ZZ_pEX& ff, const ZZ_pEX& bb,
long d, long verbose)
{
ZZ_pEX f = ff;
ZZ_pEX b = bb;
if (!IsOne(LeadCoeff(f)))
LogicError("EDF: bad args");
long n = deg(f);
long r = n/d;
if (r == 0) {
factors.SetLength(0);
return;
}
if (r == 1) {
factors.SetLength(1);
factors[0] = f;
return;
}
if (d == 1) {
RootEDF(factors, f, verbose);
return;
}
double t;
if (verbose) {
cerr << "computing EDF(" << d << "," << r << ")...";
t = GetTime();
}
factors.SetLength(0);
RecEDF(factors, f, b, d, verbose);
if (verbose) cerr << (GetTime()-t) << "\n";
}
void NormMod(zz_p& x, const zz_pX& a, const zz_pX& f)
{
if (deg(f) <= 0 || deg(a) >= deg(f))
Error("norm: bad args");
if (IsZero(a)) {
clear(x);
return;
}
zz_p t;
resultant(t, f, a);
if (!IsOne(LeadCoeff(f))) {
zz_p t1;
power(t1, LeadCoeff(f), deg(a));
inv(t1, t1);
mul(t, t, t1);
}
x = t;
}
void FindRoot(ZZ_pE& root, const ZZ_pEX& ff)
// finds a root of ff.
// assumes that ff is monic and splits into distinct linear factors
{
ZZ_pEXModulus F;
ZZ_pEX h, h1, f;
ZZ_pEX r;
f = ff;
if (!IsOne(LeadCoeff(f)))
LogicError("FindRoot: bad args");
if (deg(f) == 0)
LogicError("FindRoot: bad args");
while (deg(f) > 1) {
build(F, f);
random(r, deg(F));
if (IsOdd(ZZ_pE::cardinality())) {
PowerMod(h, r, RightShift(ZZ_pE::cardinality(), 1), F);
sub(h, h, 1);
}
else {
AbsTraceMap(h, r, F);
}
GCD(h, h, f);
if (deg(h) > 0 && deg(h) < deg(f)) {
if (deg(h) > deg(f)/2)
div(f, f, h);
else
f = h;
}
}
negate(root, ConstTerm(f));
}
void PAlgebraModDerived<type>::CRT_reconstruct(RX& H, vector<RX>& crt) const
{
if (isDryRun()) {
H = RX::zero();
return;
}
FHE_TIMER_START;
long nslots = zMStar.getNSlots();
const vector<RX>& ctab = crtTable;
clear(H);
RX tmp1, tmp2;
bool easy = true;
for (long i = 0; i < nslots; i++)
if (!IsZero(crt[i]) && !IsOne(crt[i])) {
easy = false;
break;
}
if (easy) {
for (long i=0; i<nslots; i++)
if (!IsZero(crt[i]))
H += ctab[i];
}
else {
vector<RX> crt1;
crt1.resize(nslots);
for (long i = 0; i < nslots; i++)
MulMod(crt1[i], crt[i], crtCoeffs[i], factors[i]);
evalTree(H, crtTree, crt1, 0, nslots);
}
FHE_TIMER_STOP;
}
