C++ IsOne函数代码示例

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

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