自学教程：C++ IsOne函数代码示例

NTL_START_IMPLlong 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);}

// recursive factoring (precondition: n composite)// currently only uses ECMvoid 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 primitivevoid 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_IMPLvoid 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);}

staticlong 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])); }

voidmake_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;}