lzz_pex.h

数值算法库for Windows

inline void PowerXMod(zz_pEX& h, long e, const zz_pEXModulus& F)
   { PowerXMod(h, ZZ_expo(e), F); }


inline zz_pEX PowerXMod(const ZZ& e, const zz_pEXModulus& F)
   { zz_pEX x; PowerXMod(x, e, F);  NTL_OPT_RETURN(zz_pEX, x); }

inline zz_pEX PowerXMod(long e, const zz_pEXModulus& F)
   { zz_pEX x; PowerXMod(x, e, F);  NTL_OPT_RETURN(zz_pEX, x); }


inline zz_pEX operator%(const zz_pEX& a, const zz_pEXModulus& F)
   { zz_pEX x; rem(x, a, F); NTL_OPT_RETURN(zz_pEX, x); }

inline zz_pEX& operator%=(zz_pEX& x, const zz_pEXModulus& F)
   { rem(x, x, F); return x; }

inline zz_pEX operator/(const zz_pEX& a, const zz_pEXModulus& F)
   { zz_pEX x; div(x, a, F); NTL_OPT_RETURN(zz_pEX, x); }

inline zz_pEX& operator/=(zz_pEX& x, const zz_pEXModulus& F)
   { div(x, x, F); return x; }



/*****************************************************************

                       vectors of zz_pEX's

*****************************************************************/



NTL_vector_decl(zz_pEX,vec_zz_pEX)

NTL_eq_vector_decl(zz_pEX,vec_zz_pEX)

NTL_io_vector_decl(zz_pEX,vec_zz_pEX)





/*******************************************************

              Evaluation and related problems

********************************************************/




void BuildFromRoots(zz_pEX& x, const vec_zz_pE& a);
inline zz_pEX BuildFromRoots(const vec_zz_pE& a)
   { zz_pEX x; BuildFromRoots(x, a); NTL_OPT_RETURN(zz_pEX, x); }
// computes the polynomial (X-a[0]) ... (X-a[n-1]), where n = a.length()


void eval(zz_pE& b, const zz_pEX& f, const zz_pE& a);
inline zz_pE eval(const zz_pEX& f, const zz_pE& a)
   { zz_pE x; eval(x, f, a); NTL_OPT_RETURN(zz_pE, x); }
// b = f(a)

void eval(vec_zz_pE& b, const zz_pEX& f, const vec_zz_pE& a);
inline vec_zz_pE eval(const zz_pEX& f, const vec_zz_pE& a)
   { vec_zz_pE x; eval(x, f, a); NTL_OPT_RETURN(vec_zz_pE, x); }
//  b[i] = f(a[i])

inline void eval(zz_pE& b, const zz_pX& f, const zz_pE& a)
   { conv(b, CompMod(f, rep(a), zz_pE::modulus())); }
   
inline zz_pE eval(const zz_pX& f, const zz_pE& a)
   { zz_pE x; eval(x, f, a); NTL_OPT_RETURN(zz_pE, x); }
// b = f(a)


void interpolate(zz_pEX& f, const vec_zz_pE& a, const vec_zz_pE& b);
inline zz_pEX interpolate(const vec_zz_pE& a, const vec_zz_pE& b)
   { zz_pEX x; interpolate(x, a, b); NTL_OPT_RETURN(zz_pEX, x); }
// computes f such that f(a[i]) = b[i]





/**********************************************************

         Modular Composition and Minimal Polynomials

***********************************************************/



void CompMod(zz_pEX& x, const zz_pEX& g, const zz_pEX& h, const zz_pEXModulus& F);
inline zz_pEX 
CompMod(const zz_pEX& g, const zz_pEX& h, const zz_pEXModulus& F)
   { zz_pEX x; CompMod(x, g, h, F); NTL_OPT_RETURN(zz_pEX, x); }
// x = g(h) mod f

void Comp2Mod(zz_pEX& x1, zz_pEX& x2, const zz_pEX& g1, const zz_pEX& g2,
              const zz_pEX& h, const zz_pEXModulus& F);
// xi = gi(h) mod f (i=1,2)

void Comp3Mod(zz_pEX& x1, zz_pEX& x2, zz_pEX& x3, 
              const zz_pEX& g1, const zz_pEX& g2, const zz_pEX& g3,
              const zz_pEX& h, const zz_pEXModulus& F);
// xi = gi(h) mod f (i=1..3)



// The routine build (see below) which is implicitly called
// by the various compose and UpdateMap routines builds a table
// of polynomials.  
// If zz_pEXArgBound > 0, then the table is limited in
// size to approximamtely that many KB.
// If zz_pEXArgBound <= 0, then it is ignored, and space is allocated
// so as to maximize speed.
// Initially, zz_pEXArgBound = 0.


// If a single h is going to be used with many g's
// then you should build a zz_pEXArgument for h,
// and then use the compose routine below.
// build computes and stores h, h^2, ..., h^m mod f.
// After this pre-computation, composing a polynomial of degree 
// roughly n with h takes n/m multiplies mod f, plus n^2
// scalar multiplies.
// Thus, increasing m increases the space requirement and the pre-computation
// time, but reduces the composition time.
// If zz_pEXArgBound > 0, a table of size less than m may be built.

struct zz_pEXArgument {
   vec_zz_pEX H;
};

extern long zz_pEXArgBound;


void build(zz_pEXArgument& H, const zz_pEX& h, const zz_pEXModulus& F, long m);

// m must be > 0, otherwise an error is raised

void CompMod(zz_pEX& x, const zz_pEX& g, const zz_pEXArgument& H, 
             const zz_pEXModulus& F);

inline zz_pEX 
CompMod(const zz_pEX& g, const zz_pEXArgument& H, const zz_pEXModulus& F)
   { zz_pEX x; CompMod(x, g, H, F); NTL_OPT_RETURN(zz_pEX, x); }
   



void MinPolySeq(zz_pEX& h, const vec_zz_pE& a, long m);
inline zz_pEX MinPolySeq(const vec_zz_pE& a, long m)
   { zz_pEX x; MinPolySeq(x, a, m); NTL_OPT_RETURN(zz_pEX, x); }


void MinPolyMod(zz_pEX& hh, const zz_pEX& g, const zz_pEXModulus& F);
inline zz_pEX MinPolyMod(const zz_pEX& g, const zz_pEXModulus& F)
   { zz_pEX x; MinPolyMod(x, g, F); NTL_OPT_RETURN(zz_pEX, x); }


void MinPolyMod(zz_pEX& hh, const zz_pEX& g, const zz_pEXModulus& F, long m);
inline zz_pEX MinPolyMod(const zz_pEX& g, const zz_pEXModulus& F, long m)
   { zz_pEX x; MinPolyMod(x, g, F, m); NTL_OPT_RETURN(zz_pEX, x); }

void ProbMinPolyMod(zz_pEX& hh, const zz_pEX& g, const zz_pEXModulus& F);
inline zz_pEX ProbMinPolyMod(const zz_pEX& g, const zz_pEXModulus& F)
   { zz_pEX x; ProbMinPolyMod(x, g, F); NTL_OPT_RETURN(zz_pEX, x); }

void ProbMinPolyMod(zz_pEX& hh, const zz_pEX& g, const zz_pEXModulus& F, long m);
inline zz_pEX ProbMinPolyMod(const zz_pEX& g, const zz_pEXModulus& F, long m)
   { zz_pEX x; ProbMinPolyMod(x, g, F, m); NTL_OPT_RETURN(zz_pEX, x); }

void IrredPolyMod(zz_pEX& h, const zz_pEX& g, const zz_pEXModulus& F);
inline zz_pEX IrredPolyMod(const zz_pEX& g, const zz_pEXModulus& F)
   { zz_pEX x; IrredPolyMod(x, g, F); NTL_OPT_RETURN(zz_pEX, x); }

void IrredPolyMod(zz_pEX& h, const zz_pEX& g, const zz_pEXModulus& F, long m);
inline zz_pEX IrredPolyMod(const zz_pEX& g, const zz_pEXModulus& F, long m)
   { zz_pEX x; IrredPolyMod(x, g, F, m); NTL_OPT_RETURN(zz_pEX, x); }


struct zz_pEXTransMultiplier {
   zz_pEX f0, fbi, b;
   long shamt, shamt_fbi, shamt_b;
};

void build(zz_pEXTransMultiplier& B, const zz_pEX& b, const zz_pEXModulus& F);

void TransMulMod(zz_pEX& x, const zz_pEX& a, const zz_pEXTransMultiplier& B,
               const zz_pEXModulus& F);

void UpdateMap(vec_zz_pE& x, const vec_zz_pE& a, 
         const zz_pEXTransMultiplier& B, const zz_pEXModulus& F);

inline vec_zz_pE UpdateMap(const vec_zz_pE& a,
         const zz_pEXTransMultiplier& B, const zz_pEXModulus& F)
   { vec_zz_pE x; UpdateMap(x, a, B, F); NTL_OPT_RETURN(vec_zz_pE, x); }

void ProjectPowers(vec_zz_pE& x, const vec_zz_pE& a, long k, 
                   const zz_pEXArgument& H, const zz_pEXModulus& F);
inline vec_zz_pE ProjectPowers(const vec_zz_pE& a, long k, 
                   const zz_pEXArgument& H, const zz_pEXModulus& F)
   { vec_zz_pE x; ProjectPowers(x, a, k, H, F); NTL_OPT_RETURN(vec_zz_pE, x); }

void ProjectPowers(vec_zz_pE& x, const vec_zz_pE& a, long k, const zz_pEX& h, 
                   const zz_pEXModulus& F);
inline vec_zz_pE ProjectPowers(const vec_zz_pE& a, long k, 
                   const zz_pEX& H, const zz_pEXModulus& F)
   { vec_zz_pE x; ProjectPowers(x, a, k, H, F); NTL_OPT_RETURN(vec_zz_pE, x); }

inline void project(zz_pE& x, const vec_zz_pE& a, const zz_pEX& b)
   { InnerProduct(x, a, b.rep); }

inline zz_pE project(const vec_zz_pE& a, const zz_pEX& b)
   { zz_pE x; InnerProduct(x, a, b.rep); NTL_OPT_RETURN(zz_pE, x); }



/*****************************************************************

          modular composition and minimal polynonomials
                         in towers

******************************************************************/


// composition

void CompTower(zz_pEX& x, const zz_pX& g, const zz_pEXArgument& A,
             const zz_pEXModulus& F);

inline zz_pEX CompTower(const zz_pX& g, const zz_pEXArgument& A,
             const zz_pEXModulus& F)
   { zz_pEX x; CompTower(x, g, A, F); NTL_OPT_RETURN(zz_pEX, x); }

void CompTower(zz_pEX& x, const zz_pX& g, const zz_pEX& h,
             const zz_pEXModulus& F);

inline zz_pEX CompTower(const zz_pX& g, const zz_pEX& h,
             const zz_pEXModulus& F)
   { zz_pEX x; CompTower(x, g, h, F); NTL_OPT_RETURN(zz_pEX, x); }

// prob min poly

void ProbMinPolyTower(zz_pX& h, const zz_pEX& g, const zz_pEXModulus& F,
                      long m);

inline zz_pX ProbMinPolyTower(const zz_pEX& g, const zz_pEXModulus& F,
                      long m)
   { zz_pX x; ProbMinPolyTower(x, g, F, m); NTL_OPT_RETURN(zz_pX, x); }

inline void ProbMinPolyTower(zz_pX& h, const zz_pEX& g, 
                             const zz_pEXModulus& F)
   { ProbMinPolyTower(h, g, F, deg(F)*zz_pE::degree()); }

inline zz_pX ProbMinPolyTower(const zz_pEX& g, const zz_pEXModulus& F)
   { zz_pX x; ProbMinPolyTower(x, g, F); NTL_OPT_RETURN(zz_pX, x); }


// min poly


void MinPolyTower(zz_pX& h, const zz_pEX& g, const zz_pEXModulus& F,
                      long m);

inline zz_pX MinPolyTower(const zz_pEX& g, const zz_pEXModulus& F,
                      long m)
   { zz_pX x; MinPolyTower(x, g, F, m); NTL_OPT_RETURN(zz_pX, x); }

inline void MinPolyTower(zz_pX& h, const zz_pEX& g, 
                             const zz_pEXModulus& F)
   { MinPolyTower(h, g, F, deg(F)*zz_pE::degree()); }

inline zz_pX MinPolyTower(const zz_pEX& g, const zz_pEXModulus& F)
   { zz_pX x; MinPolyTower(x, g, F); NTL_OPT_RETURN(zz_pX, x); }

// irred poly


void IrredPolyTower(zz_pX& h, const zz_pEX& g, const zz_pEXModulus& F,
                      long m);

inline zz_pX IrredPolyTower(const zz_pEX& g, const zz_pEXModulus& F,
                      long m)
   { zz_pX x; IrredPolyTower(x, g, F, m); NTL_OPT_RETURN(zz_pX, x); }

inline void IrredPolyTower(zz_pX& h, const zz_pEX& g, 
                             const zz_pEXModulus& F)
   { IrredPolyTower(h, g, F, deg(F)*zz_pE::degree()); }

inline zz_pX IrredPolyTower(const zz_pEX& g, const zz_pEXModulus& F)
   { zz_pX x; IrredPolyTower(x, g, F); NTL_OPT_RETURN(zz_pX, x); }

/*****************************************************************

                   Traces, norms, resultants

******************************************************************/

void TraceVec(vec_zz_pE& S, const zz_pEX& f);

inline vec_zz_pE TraceVec(const zz_pEX& f)
   { vec_zz_pE x; TraceVec(x, f); NTL_OPT_RETURN(vec_zz_pE, x); }


void TraceMod(zz_pE& x, const zz_pEX& a, const zz_pEXModulus& F);

inline zz_pE TraceMod(const zz_pEX& a, const zz_pEXModulus& F)
   { zz_pE x; TraceMod(x, a, F); NTL_OPT_RETURN(zz_pE, x); }

void TraceMod(zz_pE& x, const zz_pEX& a, const zz_pEX& f);

inline zz_pE TraceMod(const zz_pEX& a, const zz_pEX& f)
   { zz_pE x; TraceMod(x, a, f); NTL_OPT_RETURN(zz_pE, x); }





void NormMod(zz_pE& x, const zz_pEX& a, const zz_pEX& f);

inline zz_pE NormMod(const zz_pEX& a, const zz_pEX& f)
   { zz_pE x; NormMod(x, a, f); NTL_OPT_RETURN(zz_pE, x); }

void resultant(zz_pE& rres, const zz_pEX& a, const zz_pEX& b);

inline zz_pE resultant(const zz_pEX& a, const zz_pEX& b)
   { zz_pE x; resultant(x, a, b); NTL_OPT_RETURN(zz_pE, x); }

NTL_CLOSE_NNS

#endif