RingHom EvalHom(const PolyRing& Rx, const std::vector<RingElem>& IndetImages)
{
const char* const FnName = "EvalHom(Rx,IndetImages)";
const ring& R = CoeffRing(Rx);
if (NumIndets(Rx) != len(IndetImages))
CoCoA_ERROR(ERR::BadPolyRingHomImages, FnName);
for (long i=0; i < NumIndets(Rx); ++i)
if (owner(IndetImages[i]) != R)
CoCoA_ERROR(ERR::BadPolyRingHomImages, FnName);
return Rx->myHomCtor(R, IdentityHom(R), IndetImages);
}
ideal FrbAlexanderDual(const ideal& I, ConstRefPPMonoidElem pp)
{
MustHaveMonomialGens(I, "FrbAlexanderDual");
const SparsePolyRing polyRing = RingOf(I);
if (PPM(polyRing) != owner(pp))
CoCoA_ERROR(ERR::MixedPPMs, "FrbAlexanderDual");
const std::size_t count = NumIndets(polyRing);
Frobby::Ideal frobbyIdeal(count);
ToFrobbyIdeal(frobbyIdeal, I);
FrobbyMonomialIdealConsumer consumer(polyRing);
// Set up the point to dualize on.
WrappedMpzT* exponentVector = new WrappedMpzT[count];
try
{
for (size_t indep = 0; indep < count; ++indep)
mpz_set(exponentVector[indep].getMpzT(), mpzref(BigExponent(pp, indep)));
// Compute Alexander dual using Frobby.
Frobby::alexanderDual(frobbyIdeal, (mpz_t*)exponentVector, consumer);
}
catch (...)
{
delete[] exponentVector;
throw;
}
delete[] exponentVector;
return consumer.getIdealsRef().back();
}
void CyclRatFunct::showCoprimeCRF(){
// shows *this also with coprime numerator and denominator
// makes only sense if only x[0] appears in the numerator (not checked)
if(!verbose_INT)
return;
cout << "--------------------------------------------" << endl << endl;
cout << "Given form" << endl << endl;
showCRF();
cout << endl;
SparsePolyRing R=owner(num);
SparsePolyRing P=NewPolyRing_DMPI(RingQQ(),symbols("t"));
vector<RingElem> Im(NumIndets(R),zero(P));
Im[0]=indets(P)[0];
RingHom phi=PolyAlgebraHom(R,P,Im);
RingElem f(phi(num));
RingElem g(denom2poly(P,denom));
RingElem h=CoCoA::gcd(f,g);
f/=h;
g/=h;
cout << "Coprime numerator (for denom with remaining factor 1)" << endl <<endl;
factorization<RingElem> gf=factor(g);
cout << f/gf.myRemainingFactor() << endl << endl << "Factorization of denominator" << endl << endl;
size_t nf=gf.myFactors().size();
for(size_t i=0;i<nf;++i)
cout << gf.myFactors()[i] << " mult " << gf.myMultiplicities()[i] << endl;
cout << "--------------------------------------------" << endl;
}
/* ASSUMES the two args are never equal */
static int pp_cmp(const void *arg1, const void *arg2)
{
// int var, ans;
const int **pp1 = (const int**)arg1;
const int **pp2 = (const int**)arg2;
// ring R = pp_cmp_ring;
const int nvars = NumIndets(*pp_cmp_PPM);
// term PP1, PP2;
// PP1 = term_init(R->indetsNo);
vector<long> expv1(nvars);
vector<long> expv2(nvars);
for (int var = 0; var < nvars; ++var)
{
expv1[var] = pp1[0][var];
expv2[var] = pp2[0][var];
}
return cmp(PPMonoidElem(*pp_cmp_PPM, expv1), PPMonoidElem(*pp_cmp_PPM, expv2));
// term_put_nth(PP1, (var+1), pp1[0][var] * iv_get_nth(R->weights, var+1));
// PP2 = term_init(R->indetsNo);
// for (var = 0; var < nvars; var++)
// term_put_nth(PP2, (var+1), pp2[0][var] * iv_get_nth(R->weights, var+1));
// ans = term_is_gt(PP1, PP2, R);
// term_free(PP1); term_free(PP2);
// if (ans) return 1;
// return -1;
}
RingHom EvalHom(const PolyRing& Rx, const BigRat& q) // Maps f in R[x] into f(q) in R
{
if (NumIndets(Rx) != 1) CoCoA_ERROR(ERR::BadArg, "EvalHom(Rx,N)");
const ring& R = CoeffRing(Rx);
const vector<RingElem> IndetImage(1, RingElem(R,q));
return Rx->myHomCtor(R, IdentityHom(R), IndetImage);
}
RingHom EvalHom(const PolyRing& Rx, ConstRefRingElem r) // Maps f in R[x] into f(r) in R
{
if (NumIndets(Rx) != 1) CoCoA_ERROR(ERR::BadArg, "EvalHom(Rx,r)");
const ring& R = CoeffRing(Rx);
if (owner(r) != R) CoCoA_ERROR(ERR::MixedRings, "EvalHom(Rx,r");
const vector<RingElem> IndetImage(1, r);
return Rx->myHomCtor(R, IdentityHom(R), IndetImage);
}
// Rx is the domain, S is the codomain
RingHom PolyRingHom(const PolyRing& Rx, const ring& S, RingHom CoeffHom, const std::vector<RingElem>& IndetImages)
{
const char* const FnName = "PolyRingHom(Rx,S,CoeffHom,IndetImages)";
if (domain(CoeffHom) != CoeffRing(Rx))
CoCoA_ERROR(ERR::MixedCoeffRings, FnName);
if (IsPolyRing(S) && codomain(CoeffHom) == CoeffRing(S))
CoeffHom = CoeffEmbeddingHom(S)(CoeffHom);
if (codomain(CoeffHom) != S)
CoCoA_ERROR(ERR::BadCodomain, FnName);
if (NumIndets(Rx) != len(IndetImages))
CoCoA_ERROR(ERR::BadPolyRingHomImages, FnName);
for (long i=0; i < NumIndets(Rx); ++i)
if (owner(IndetImages[i]) != S)
CoCoA_ERROR(ERR::BadPolyRingHomImages, FnName);
return Rx->myHomCtor(S, CoeffHom, IndetImages);
}
// Simple rather than efficient (esp. the call to eval)
std::vector<RingElem> BM_generic(const SparsePolyRing& P, const ConstMatrixView& pts)
{
if (CoeffRing(P) != RingOf(pts)) CoCoA_ERROR(ERR::MixedRings, "Buchberger-Moeller");
if (NumIndets(P) < NumCols(pts)) CoCoA_ERROR(ERR::IncompatDims, "Buchberger-Moeller");
const long NumPts = NumRows(pts);
const long dim = NumCols(pts);
const ring k = CoeffRing(P);
vector<RingElem> GB;
const PPMonoid TT = PPM(P);
QBGenerator QBG(TT);
QBG.myCornerPPIntoQB(one(TT));
matrix M = NewDenseMat(k, 1, NumPts);
// Fill first row with 1:
for (int i=0; i<NumPts; ++i) SetEntry(M,0,i, 1);
// The next loop removes the last indets from consideration.
for (int i=dim; i < NumIndets(TT); ++i)
QBG.myCornerPPIntoAvoidSet(indet(TT,i));
while (!QBG.myCorners().empty())
{
const PPMonoidElem t = QBG.myCorners().front();
const vector<RingElem> v = eval(t, pts);
ConstMatrixView NewRow = RowMat(v);
const matrix a = LinSolve(transpose(M), transpose(NewRow));
if (IsValidSolution(a))
{
QBG.myCornerPPIntoAvoidSet(t);
RingElem NewGBElem = monomial(P, one(k), t);
const vector<PPMonoidElem>& QB = QBG.myQB();
for (int i=0; i < NumRows(M); ++i)
NewGBElem -= monomial(P, a(i,0), QB[i]);
GB.push_back(NewGBElem);
}
else
{
QBG.myCornerPPIntoQB(t);
M = NewDenseMat(ConcatVer(M, NewRow));
}
}
return GB;
}
RingElem FrbMultigradedHilbertPoincareNumerator(const ideal& I) {
MustHaveMonomialGens(I, "AssociatedPrimes");
const SparsePolyRing polyRing = RingOf(I);
Frobby::Ideal frobbyIdeal(NumIndets(polyRing));
ToFrobbyIdeal(frobbyIdeal, I);
FrobbyPolynomialConsumer consumer(polyRing);
Frobby::multigradedHilbertPoincareSeries(frobbyIdeal, consumer);
return consumer.getPolyRef();
}
RingHom PolyAlgebraHom(const PolyRing& Rx, const ring& Ry, const std::vector<RingElem>& IndetImages)
{
const char* const FnName = "PolyAlgebraHom(Rx,Ry,IndetImages)";
// Check that IndetImages are sensible...
if (NumIndets(Rx) != len(IndetImages))
CoCoA_ERROR(ERR::BadPolyRingHomImages, FnName);
for (long i=0; i < NumIndets(Rx); ++i)
if (owner(IndetImages[i]) != Ry)
CoCoA_ERROR(ERR::BadPolyRingHomImages, FnName);
// // Special case: codomain is coeff ring.
// if (Ry == CoeffRing(Rx))
// return Rx->myHomCtor(Ry, IdentityHom(Ry), IndetImages);
// // General case: codomain must be a poly ring with same coeffs
// if (!IsPolyRing(Ry))
// CoCoA_ERROR(ERR::BadCodomain, FnName);
// if (CoeffRing(Rx) != CoeffRing(Ry))
// CoCoA_ERROR(ERR::MixedCoeffRings, FnName);
// return Rx->myHomCtor(Ry, CoeffEmbeddingHom(Ry), IndetImages);
return Rx->myHomCtor(Ry, CanonicalHom(CoeffRing(Rx),Ry), IndetImages);
}
long FrbDimension(const ideal& I) {
MustHaveMonomialGens(I, "Dimension");
const SparsePolyRing polyRing = RingOf(I);
Frobby::Ideal frobbyIdeal(NumIndets(polyRing));
ToFrobbyIdeal(frobbyIdeal, I);
BigInt dim;
Frobby::dimension(frobbyIdeal, mpzref(dim));
return ConvertTo<long>(dim);
}
void FrbPrimaryDecomposition(std::vector<ideal>& components, const ideal& I)
{
MustHaveMonomialGens(I, "PrimaryDecomposition");
const SparsePolyRing polyRing = RingOf(I);
Frobby::Ideal frobbyIdeal(NumIndets(polyRing));
ToFrobbyIdeal(frobbyIdeal, I);
FrobbyMonomialIdealConsumer consumer(polyRing);
Frobby::primaryDecomposition(frobbyIdeal, consumer);
consumer.getIdealsRef().swap(components);
}
RingElem FrbTotalDegreeHilbertPoincareNumerator(const ideal& I,
const RingElem& base) {
MustHaveMonomialGens(I, "AssociatedPrimes");
const SparsePolyRing polyRing = RingOf(I);
Frobby::Ideal frobbyIdeal(NumIndets(polyRing));
ToFrobbyIdeal(frobbyIdeal, I);
FrobbyEvalPolynomialConsumer consumer(base);
Frobby::univariateHilbertPoincareSeries(frobbyIdeal, consumer);
return consumer.getPolyRef();
}
void FrbAssociatedPrimes(std::vector<ideal>& primes, const ideal& I)
{
MustHaveMonomialGens(I, "AssociatedPrimes");
const SparsePolyRing polyRing = RingOf(I);
Frobby::Ideal frobbyIdeal(NumIndets(polyRing));
ToFrobbyIdeal(frobbyIdeal, I);
FrobbyMonomialIdealConsumer consumer(polyRing);
Frobby::associatedPrimes(frobbyIdeal, consumer);
consumer.getIdealsRef().swap(primes);
}
ideal FrbMaximalStandardMonomials(const ideal& I)
{
MustHaveMonomialGens(I, "MaximalStandardMonomials");
const SparsePolyRing polyRing = RingOf(I);
Frobby::Ideal frobbyIdeal(NumIndets(polyRing));
ToFrobbyIdeal(frobbyIdeal, I);
FrobbyMonomialIdealConsumer consumer(polyRing);
Frobby::maximalStandardMonomials(frobbyIdeal, consumer);
return consumer.getIdealsRef().back();
}
ideal FrbAlexanderDual(const ideal& I)
{
MustHaveMonomialGens(I, "AlexanderDual");
const SparsePolyRing polyRing = RingOf(I);
Frobby::Ideal frobbyIdeal(NumIndets(polyRing));
ToFrobbyIdeal(frobbyIdeal, I);
FrobbyMonomialIdealConsumer consumer(polyRing);
Frobby::alexanderDual(frobbyIdeal, (mpz_t*)0, consumer);
return consumer.getIdealsRef().back();
}
ideal IdealOfPoints(const SparsePolyRing& P, const ConstMatrixView& M)
{
if (CoeffRing(P) != RingOf(M)) CoCoA_ERROR(ERR::MixedRings, "IdealOfPoints");
if (NumIndets(P) != NumCols(M)) CoCoA_ERROR(ERR::BadMatrixSize, "IdealOfPoints");
if (DuplicateRows(M)) CoCoA_ERROR("Duplicate points", "IdealOfPoints");
ideal I(P, std::vector<RingElem>(0));
if (IsFiniteField(CoeffRing(P))) I = ideal(P, BM_modp(P, M));
else if (IsQQ(CoeffRing(P))) I = ideal(P, BM_QQ(P, M));
// generic case
else I = ideal(P, BM_generic(P, M));
SetGBasisAsGens(I);
return I;
}
