C++ vec_ZZ_p::length方法代码示例

void sub(vec_ZZ_p& x, const vec_ZZ_p& a, const vec_ZZ_p& b)
{
    long n = a.length();
    if (b.length() != n) LogicError("vector sub: dimension mismatch");
    x.SetLength(n);
    long i;
    for (i = 0; i < n; i++)
        sub(x[i], a[i], b[i]);
}

void InnerProduct(ZZ_p& x, const vec_ZZ_p& a, const vec_ZZ_p& b)
{
    long n = min(a.length(), b.length());
    long i;
    NTL_ZZRegister(accum);
    NTL_ZZRegister(t);

    clear(accum);
    for (i = 0; i < n; i++) {
        mul(t, rep(a[i]), rep(b[i]));
        add(accum, accum, t);
    }

    conv(x, accum);
}

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) 
      LogicError("ProjectPowers: bad args");
   if (NTL_OVERFLOW(k, 1, 0)) 
      ResourceError("ProjectPowers: excessive 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 clear(vec_ZZ_p& x)
{
    long n = x.length();
    long i;
    for (i = 0; i < n; i++)
        clear(x[i]);
}

void InnerProduct(ZZ_pX& x, const vec_ZZ_p& v, long low, long high, 
                   const vec_ZZ_pX& H, long n, ZZVec& t)
{
   NTL_ZZRegister(s);
   long i, j;

   for (j = 0; j < n; j++)
      clear(t[j]);

   high = min(high, v.length()-1);
   for (i = low; i <= high; i++) {
      const vec_ZZ_p& h = H[i-low].rep;
      long m = h.length();
      const ZZ& w = rep(v[i]);

      for (j = 0; j < m; j++) {
         mul(s, w, rep(h[j]));
         add(t[j], t[j], s);
      }
   }

   x.rep.SetLength(n);
   for (j = 0; j < n; j++)
      conv(x.rep[j], t[j]);
   x.normalize();
}

static void StripZeroes(vec_ZZ_p& x)
{
   long n = x.length();
   while (n > 0 && IsZero(x[n-1]))
      n--;
   x.SetLength(n);
}

void conv(vec_ZZ& x, const vec_ZZ_p& a)
{
   long n = a.length();
   x.SetLength(n);
   long i;
   for (i = 0; i < n; i++)
      x[i] = rep(a[i]);
}

void negate(vec_ZZ_p& x, const vec_ZZ_p& a)
{
    long n = a.length();
    x.SetLength(n);
    long i;
    for (i = 0; i < n; i++)
        negate(x[i], a[i]);
}

void mul(vec_ZZ_p& x, const vec_ZZ_p& a, long b_in)
{
    NTL_ZZ_pRegister(b);
    b = b_in;
    long n = a.length();
    x.SetLength(n);
    long i;
    for (i = 0; i < n; i++)
        mul(x[i], a[i], b);
}

long IsZero(const vec_ZZ_p& a)
{
    long n = a.length();
    long i;

    for (i = 0; i < n; i++)
        if (!IsZero(a[i]))
            return 0;

    return 1;
}

void MinPolySeq(ZZ_pX& h, const vec_ZZ_p& a, long m)
{
   if (m < 0) LogicError("MinPoly: bad args");
   if (NTL_OVERFLOW(m, 1, 0)) LogicError("MinPoly: bad args");
   if (a.length() < 2*m) LogicError("MinPoly: sequence too short");

   if (m > NTL_ZZ_pX_BERMASS_CROSSOVER)
      GCDMinPolySeq(h, a, m);
   else
      BerlekampMassey(h, a, m);
}

static
void FindFactors(vec_ZZ_pX& factors, const ZZ_pX& f, const ZZ_pX& g,
                 const vec_ZZ_p& roots)
{
   long r = roots.length();

   factors.SetMaxLength(r);
   factors.SetLength(0);

   RecFindFactors(factors, f, g, roots, 0, r-1);
}

// inner product (svec_ZZ and svec_ZZ_p)
inline void InnerProduct(ZZ_p& result, const svec_ZZ& a, const vec_ZZ_p& b) {
  if (a.length()!=b.length()) {
    cerr<<"InnerProduct() length mismatch\n";
    exit(1);
  }
  clear(result);
  long an = a.nvalues();
  const svec_ZZ::index_t* ai = a.indices();
  const svec_ZZ::value_t* av = a.values();
  for (long i=0; i<an; ++i)
    result += to_ZZ_p(av[i])*b[ai[i]];
}

static
void IterFindFactors(vec_ZZ_pX& factors, const ZZ_pX& f,
                     const ZZ_pX& g, const vec_ZZ_p& roots)
{
   long r = roots.length();
   long i;
   ZZ_pX h;

   factors.SetLength(r);

   for (i = 0; i < r; i++) {
      sub(h, g, roots[i]);
      GCD(factors[i], f, h);
   }
}

void eval(vec_ZZ_p& b, const ZZ_pX& f, const vec_ZZ_p& a)
// naive algorithm:  repeats Horner
{
   if (&b == &f.rep) {
      vec_ZZ_p bb;
      eval(bb, f, a);
      b = bb;
      return;
   }

   long m = a.length();
   b.SetLength(m);
   long i;
   for (i = 0; i < m; i++) 
      eval(b[i], f, a[i]);
}