CoCoA » CoCoALib

    CoCoA_ASSERT( IsIndet(h) );

    CoCoA_ASSERT( IsOne(wdeg(h)[0]) );

    const BigInt d = wdeg(v)[0];

    ModuleElem resv(owner(v));

    for (long i=0; i<NumCompts(v); ++i)

      resv += e[i]*(homog(v[i],h)*power(h,d-wdeg(v)[0])); // and shifts ???

    if (deg(f) == 0) return abs(LC(f));

    const long x_ind = UnivariateIndetIndex(f);

    if (x_ind < 0) CoCoA_THROW_ERROR(ERR::BadArg, "FixedDivisor: expected univariate poly");

    const BigInt cont = ConvertTo<BigInt>(content(f)); // requires coeffs to be integers!

    vector<RingElem> EvalPt(NumIndets(P), zero(k)); // initially all zeroes

    long x_lo = 0;

  RingElem HilbertNumQuot(const ideal& I)

  {

    if (!IsHomog(I))  CoCoA_THROW_ERROR("not homogeneous", "HilbertNumQuot");

    if (IsZero(I)) return one(QQt);

    DenseUPolyRing HSRing = StartPoincareQQt((int)NumIndets(RingOf(I)));

    TermList TL = NewLPPTList(GBasis(I));

    bool IsPrimary_0dimFin(const ideal& I)

    {

      VerboseLog VERBOSE("IsPrimary_0dimFin");

      if (!IsFiniteField(K))

        CoCoA_THROW_ERROR("CoeffRing must be finite field", "IsPrimary_0dimFin");

      if (!IsZeroDim(I))

        CoCoA_THROW_ERROR("arguments must be in the same ring", "MultiplicationMat");

      if (!IsZeroDim(I))

        CoCoA_THROW_ERROR("ideal must be 0-dimensional", "MultiplicationMat");

      vector<PPMonoidElem> QB = QuotientBasisSorted(I);

      //      std::map<PPMonoidElem, long> QBPosn = QBPositions(QB);

      RingElem f = NF(f_orig, I);

    if (RM==Rx)

      // TODO: convert M into matrix of coefficients (if possible)

      CoCoA_THROW_ERROR(ERR::NYI, "MinPoly");

    //   If (IsZZ(R) or IsQQ(R)) Then

    //     M := CanonicalHom(R, K)( M );

    //     R := K;

    //if R = RingOf(X) then return MinPolyInKx(M, X); endif;

    //    const vector<PPMonoidElem> QB = QuotientBasisSorted(I);

    const long LenQB = len(QuotientBasis(I)); // multiplicity

    LinDepMill ILD(K, LenQB);

    //  const double T = CpuTime();

    const ring& P = owner(f_orig);

    const ring& P_x = owner(x);

    // fare tutti i controlli sugli anelli

    if (K != CoeffRing(P_x))

      CoCoA_THROW_ERROR("incompatible coeff rings", "MinPolyQuotDef");

    //  const double T = CpuTime();

    const ring& P = owner(f_orig);

    const ring& P_x = owner(x);

    RingHom psi = CoeffEmbeddingHom(P);

    // fare tutti i controlli sugli anelli

    if (K != CoeffRing(P_x))

    //VERBOSE(99) << f_orig << std::flush;

    //---- "MultiplicationMat"  fxQB

    double U = CpuTime();

    vector<RingElem> fxQB(len(QB));

    for (long j=0; j<len(QB); ++j)

    {

      const RingHom coeff = CoeffEmbeddingHom(P);

      RingElem g = f;

      const int s = sign(LC(g));

      while (true)

      {

      else

        PushBack(OddPart, coeff(it), power(pp,d/2)); // integer division!

    }

    // Fiddle answer so that LC is positive.

    RingElem ans = power(EvenPart,2) - x*power(OddPart,2);

    if (sign(LC(ans)) < 0) ans *= -1;

      const int d = deg(PP(it));

      PushBack(part[d%3], coeff(it), power(pp, d/3)); // integer division!

    }

    const RingElem part012 = part[0]*part[1]*part[2];

    // Fiddle answer so that LC is positive.

    RingElem ans = power(part[0],3) + x*(power(part[1],3)-3*part012 + x*power(part[2],3));

    if (IsZero(f)) CoCoA_THROW_ERROR(ERR::NotNonZero, FnName);

    const int var = UnivariateIndetIndex(f);

    if (var < 0) CoCoA_THROW_ERROR(ERR::NotUnivariate, FnName);

    vector<RingElem> seq;  seq.reserve(1+deg(f));

    RingElem prev = f*ConvertTo<BigInt>(CommonDenom(f));

    // ??? SLUG:  remove content from prev???

  {

    if (!IsSparsePolyRing(RingOf(M)))

      CoCoA_THROW_ERROR(ERR::NYI, "SubmoduleImpl::IsContained");

    for (long i=0; i < len(g); ++i)

      if (!IsElem(g[i], N)) return false;

    return true;

      CoCoA_THROW_ERROR(ERR::ZeroGradingDim, "IsHomog(submodule)");

    if (IsZero(M)) return true;

    // Now we know I is non-trivial.

    const long GBsize = len(GB); // MUST BE A REDUCED GBASIS !!!

    for (long i=0; i < GBsize; ++i)

      if (!IsHomog(GB[i]))  return false;

    if (GradingDim(P)==0)

      CoCoA_THROW_ERROR(ERR::ZeroGradingDim, "LT(submodule)");

    const vector<ModuleElem>& e = gens(AmbientFreeModule(M));

    vector<ModuleElem> LTs;

    const long GBsize = len(GB);

    for (long i=0; i < GBsize; ++i)

  {

  public: // data members

    int m;

    SparsePolyRing env;

  public:

    cF5_t(const vector<RingElem> &I);

  class matrF5_t{

  private:

    SparsePolyRing env;

  public:

    unsigned int curr_deg,curr_poly,red2zero,n_indets,max_gen_deg;

    vector<PPMonoidElem> mtPPMindets;

    vector<RingElem> gens;

    GB_t GB;

    const long dim = 4;

    const FreeModule F = NewFreeModule(R, dim);

    const vector<ModuleElem>& e = gens(F);

    CoCoA_ASSERT_ALWAYS(len(e) == dim);

// This does not yet compile

//   for (long i=0; i < dim; ++i)

  ideal NewQueenMovesFrom(SparsePolyRing P, long Csb, long sq1, long sq2)

  {

    vector<RingElem> g;

    for ( long i=sq2+1 ; i<=Csb ; ++i )

      g.push_back(x * CsbSquareIndet(P, Csb, sq1, i));

    CoCoA_ASSERT_ALWAYS(IsMonomial(f) || B > 0);

    const ring& P = owner(f);

    const long index = UnivariateIndetIndex(f);

    const RingElem g = Fstar(f);

    // Check that bound is invariant if poly is multiplied by a power of x

    const ring& P = owner(f);

    const long index = UnivariateIndetIndex(f);

    for (int k=1; k < 20; ++k)

      CoCoA_ASSERT_ALWAYS(RootBound2(f*power(x,k)) == B);

    GlobalManager CoCoAFoundations;

    ring P = NewPolyRing(RingQQ(), symbols("x,y"));

    // Linear polynomials

    CheckUPB(x);

    CoCoA_ASSERT_ALWAYS(IsMonomial(f) || B > 0);

    const ring& P = owner(f);

    const long index = UnivariateIndetIndex(f);

    const RingElem radf = radical(f);

    // Check that bound is invariant if poly is multiplied by a power of x

    const ring& P = owner(f);

    const long index = UnivariateIndetIndex(f);

    for (int k=1; k < 20; ++k)

      CoCoA_ASSERT_ALWAYS(RootBound2(f*power(x,k)) == B);