void BuildSparseIrred(GF2X& f, long n) { if (n <= 0) Error("SparseIrred: n <= 0"); if (NTL_OVERFLOW(n, 1, 0)) Error("overflow in BuildSparseIrred"); if (n == 1) { SetX(f); return; } if (n <= 2048) { if (GF2X_irred_tab[n][1] == 0) { clear(f); SetCoeff(f, n); SetCoeff(f, GF2X_irred_tab[n][0]); SetCoeff(f, 0); } else { clear(f); SetCoeff(f, n); SetCoeff(f, GF2X_irred_tab[n][0]); SetCoeff(f, GF2X_irred_tab[n][1]); SetCoeff(f, GF2X_irred_tab[n][2]); SetCoeff(f, 0); } return; } long k3, k2, k1; k3 = FindTrinom(n); if (k3) { clear(f); SetCoeff(f, n); SetCoeff(f, k3); SetCoeff(f, 0); return; } k3 = FindPent(n, k2, k1); if (k3) { clear(f); SetCoeff(f, n); SetCoeff(f, k3); SetCoeff(f, k2); SetCoeff(f, k1); SetCoeff(f, 0); return; } // the following is probably of only theoretical value... // it is reasonable to conjecture that for all n >= 2, // there is either an irreducible trinomial or pentanomial // of degree n. BuildIrred(f, n); }
void to_mat_ZZ_p_crt_rep(mat_ZZ_p_crt_rep& X, const mat_ZZ_p& A) { long n = A.NumRows(); long m = A.NumCols(); const MatPrime_crt_helper& H = get_MatPrime_crt_helper_info(); long nprimes = H.GetNumPrimes(); if (NTL_OVERFLOW(nprimes, CRT_BLK, 0)) ResourceError("overflow"); // this is pretty academic X.rep.SetLength(nprimes); for (long k = 0; k < nprimes; k++) X.rep[k].SetDims(n, m); ZZ_pContext context; context.save(); bool seq = (double(n)*double(m)*H.GetCost() < PAR_THRESH); // FIXME: right now, we just partition the rows, but if // #cols > #rows, we should perhaps partition the cols NTL_GEXEC_RANGE(seq, n, first, last) NTL_IMPORT(n) NTL_IMPORT(m) NTL_IMPORT(nprimes) context.restore(); MatPrime_crt_helper_scratch scratch; Vec<MatPrime_residue_t> remainders_store; remainders_store.SetLength(nprimes*CRT_BLK); MatPrime_residue_t *remainders = remainders_store.elts(); for (long i = first; i < last; i++) { const ZZ_p *a = A[i].elts(); long jj = 0; for (; jj <= m-CRT_BLK; jj += CRT_BLK) { for (long j = 0; j < CRT_BLK; j++) reduce(H, rep(a[jj+j]), remainders + j*nprimes, scratch); for (long k = 0; k < nprimes; k++) { MatPrime_residue_t *x = X.rep[k][i].elts(); for (long j = 0; j < CRT_BLK; j++) x[jj+j] = remainders[j*nprimes+k]; } } if (jj < m) { for (long j = 0; j < m-jj; j++) reduce(H, rep(a[jj+j]), remainders + j*nprimes, scratch); for (long k = 0; k < nprimes; k++) { MatPrime_residue_t *x = X.rep[k][i].elts(); for (long j = 0; j < m-jj; j++) x[jj+j] = remainders[j*nprimes+k]; } } } NTL_GEXEC_RANGE_END }
void BuildIrred(GF2X& f, long n) { if (n <= 0) Error("BuildIrred: n must be positive"); if (NTL_OVERFLOW(n, 1, 0)) Error("overflow in BuildIrred"); if (n == 1) { SetX(f); return; } GF2X g; _ntl_ulong i; i = 0; do { ConvertBits(g, 2*i+1); SetCoeff(g, n); i++; } while (!IterIrredTest(g)); f = g; }
void InnerProduct(zz_p& x, const vec_zz_p& a, const vec_zz_p& b, long offset) { if (offset < 0) LogicError("InnerProduct: negative offset"); if (NTL_OVERFLOW(offset, 1, 0)) ResourceError("InnerProduct: offset too big"); long n = min(a.length(), b.length()+offset); long i; long accum, t; long p = zz_p::modulus(); mulmod_t pinv = zz_p::ModulusInverse(); const zz_p *ap = a.elts(); const zz_p *bp = b.elts(); accum = 0; for (i = offset; i < n; i++) { t = MulMod(rep(ap[i]), rep(bp[i-offset]), p, pinv); accum = AddMod(accum, t, p); } x.LoopHole() = accum; }
void LeftShift(zz_pX& x, const zz_pX& a, long n) { if (IsZero(a)) { clear(x); return; } if (n < 0) { if (n < -NTL_MAX_LONG) clear(x); else RightShift(x, a, -n); return; } if (NTL_OVERFLOW(n, 1, 0)) Error("overflow in LeftShift"); long m = a.rep.length(); x.rep.SetLength(m+n); long i; for (i = m-1; i >= 0; i--) x.rep[i+n] = a.rep[i]; for (i = 0; i < n; i++) clear(x.rep[i]); }
void ProjectPowers(vec_zz_p& x, const vec_zz_p& a, long k, const zz_pXArgument& H, const zz_pXModulus& F) { long n = F.n; if (a.length() > n || k < 0 || NTL_OVERFLOW(k, 1, 0)) Error("ProjectPowers: bad args"); long m = H.H.length()-1; long l = (k+m-1)/m - 1; zz_pXMultiplier M; build(M, H.H[m], F); vec_zz_p s(INIT_SIZE, n); s = a; StripZeroes(s); x.SetLength(k); for (long i = 0; i <= l; i++) { long m1 = min(m, k-i*m); zz_p* w = &x[i*m]; for (long j = 0; j < m1; j++) InnerProduct(w[j], H.H[j].rep, s); if (i < l) UpdateMap(s, s, M, F); } }
void GF2X::SetMaxLength(long n) { if (n < 0) LogicError("GF2X::SetMaxLength: negative length"); if (NTL_OVERFLOW(n, 1, 0)) ResourceError("GF2X::SetMaxLength: excessive length"); long w = (n + NTL_BITS_PER_LONG - 1)/NTL_BITS_PER_LONG; xrep.SetMaxLength(w); }
void xdouble::SetOutputPrecision(long p) { if (p < 1) p = 1; if (NTL_OVERFLOW(p, 1, 0)) ResourceError("xdouble: output precision too big"); oprec = p; }
void quad_float::SetOutputPrecision(long p) { if (p < 1) p = 1; if (NTL_OVERFLOW(p, 1, 0)) ResourceError("quad_float: output precision too big"); oprec = p; }
void InvPrec(RR& x, const RR& a, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("InvPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; inv(x, a); RR::prec = old_p; }
void DivPrec(RR& x, const RR& a, const RR& b, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("DivPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; div(x, a, b); RR::prec = old_p; }
void NegatePrec(RR& x, const RR& a, const RR& b, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("NegatePrec: bad precsion"); long old_p = RR::prec; RR::prec = p; negate(x, a); RR::prec = old_p; }
void ConvPrec(RR& x, const char *s, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("ConvPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; conv(x, s); RR::prec = old_p; }
void SqrRootPrec(RR& x, const RR& a, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("SqrRootPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; SqrRoot(x, a); RR::prec = old_p; }
void ConvPrec(RR& x, const quad_float& a, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("ConvPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; conv(x, a); RR::prec = old_p; }
void TruncPrec(RR& x, const RR& a, const RR& b, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("TruncPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; trunc(x, a); RR::prec = old_p; }
void ConvPrec(RR& x, unsigned long a, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("ConvPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; conv(x, a); RR::prec = old_p; }
void RoundPrec(RR& x, const RR& a, const RR& b, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("RoundPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; round(x, a); RR::prec = old_p; }
void CeilPrec(RR& x, const RR& a, const RR& b, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("CeilPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; ceil(x, a); RR::prec = old_p; }
void MakeRRPrec(RR& x, const ZZ& a, long e, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("MakeRRPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; MakeRR(x, a, e); RR::prec = old_p; }
void RR::SetOutputPrecision(long p) { if (p < 1) p = 1; if (NTL_OVERFLOW(p, 1, 0)) ResourceError("RR: output precision too high"); oprec = p; }
void RR::SetPrecision(long p) { if (p < 53) p = 53; if (NTL_OVERFLOW(p, 1, 0)) ResourceError("RR: precision too high"); prec = p; }
void ConvPrec(RR& x, const RR& a, long p) { if (p < 1 || NTL_OVERFLOW(p, 1, 0)) Error("ConvPrec: bad precsion"); long old_p = RR::prec; RR::prec = p; normalize(x, a); RR::prec = old_p; }
void MinPolySeq(zz_pX& h, const vec_zz_p& a, long m) { if (m < 0 || NTL_OVERFLOW(m, 1, 0)) Error("MinPoly: bad args"); if (a.length() < 2*m) Error("MinPoly: sequence too short"); if (m > NTL_zz_pX_BERMASS_CROSSOVER) GCDMinPolySeq(h, a, m); else BerlekampMassey(h, a, m); }
void ConvPrec(RR& x, const RR& a, long p) { if (p < 1) LogicError("ConvPrec: bad precsion"); if (NTL_OVERFLOW(p, 1, 0)) ResourceError("ConvPrec: precsion too big"); RRPush push; RR::prec = p; normalize(x, a); }
void DivPrec(RR& x, const RR& a, const RR& b, long p) { if (p < 1) LogicError("DivPrec: bad precsion"); if (NTL_OVERFLOW(p, 1, 0)) ResourceError("DivPrec: bad precsion"); RRPush push; RR::prec = p; div(x, a, b); }
void ConvPrec(RR& x, double a, long p) { if (p < 1) LogicError("ConvPrec: bad precsion"); if (NTL_OVERFLOW(p, 1, 0)) ResourceError("ConvPrec: bad precsion"); RRPush push; RR::prec = p; conv(x, a); }
void InvPrec(RR& x, const RR& a, long p) { if (p < 1) LogicError("InvPrec: bad precsion"); if (NTL_OVERFLOW(p, 1, 0)) ResourceError("InvPrec: bad precsion"); RRPush push; RR::prec = p; inv(x, a); }
void MakeRRPrec(RR& x, const ZZ& a, long e, long p) { if (p < 1) LogicError("MakeRRPrec: bad precsion"); if (NTL_OVERFLOW(p, 1, 0)) ResourceError("MakeRRPrec: precsion too big"); RRPush push; RR::prec = p; MakeRR(x, a, e); }
void FactorInt(FacVec& fvec, long n) { if (n <= 1) LogicError("internal error: FactorInt(FacVec,long n) with n<=1"); if (NTL_OVERFLOW(n, 1, 0)) ResourceError("internal error: FactorInt(FacVec,long n) with n too large"); long NumFactors; long q; fvec.SetLength(2*NextPowerOfTwo(n)); NumFactors = 0; q = 2; while (n != 1) { if (n%q == 0) { fvec[NumFactors].q = q; n = n/q; fvec[NumFactors].a = 1; fvec[NumFactors].val = q; while (n%q == 0) { n = n/q; (fvec[NumFactors].a)++; fvec[NumFactors].val *= q; } fvec[NumFactors].link = -1; NumFactors++; } q++; } fvec.SetLength(2*NumFactors-1); long lo = 0; long hi = NumFactors - 1; while (lo < hi) { FindMin(fvec, lo, hi); FindMin(fvec, lo+1, hi); hi++; fvec[hi].link = lo; fvec[hi].val = fvec[lo].val * fvec[lo+1].val; lo += 2; } }