#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
ideal id_ChineseRemainder(ideal *xx, number *q, int rl, const ring r)
poly prMoveR(poly &p, ring src_r, ring dest_r)
void mp_RecMin(int ar, ideal result, int &elems, matrix a, int lr, int lc, poly barDiv, ideal R, const ring r)
produces recursively the ideal of all arxar-minors of a
static int tCompare(const poly a, const poly b)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
#define omFreeSize(addr, size)
#define idSimpleAdd(A, B)
matrix idDiffOp(ideal I, ideal J, BOOLEAN multiply)
const CanonicalForm CFMap CFMap int &both_non_zero int n
static short rVar(const ring r)
#define rVar(r) (r->N)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
int pCompare_qsort(const void *a, const void *b)
CanonicalForm divide(const CanonicalForm &ff, const CanonicalForm &f, const CFList &as)
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
ideal idMultSect(resolvente arg, int length)
static void ipPrint_MA0(matrix m, const char *name)
void WerrorS(const char *s)
ideal idModulo(ideal h2, ideal h1, tHomog hom, intvec **w)
#define TEST_V_INTERSECT_ELIM
void mp_MinorToResult(ideal result, int &elems, matrix a, int r, int c, ideal R, const ring)
entries of a are minors and go to result (only if not in R)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
#define pEqualPolys(p1, p2)
ideal idMinEmbedding(ideal arg, BOOLEAN inPlace, intvec **w)
poly singclap_pdivide(poly f, poly g, const ring r)
static bool rIsPluralRing(const ring r)
we must always have this test!
long sm_ExpBound(ideal m, int di, int ra, int t, const ring currRing)
ideal idQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN resultIsIdeal)
static number p_SetCoeff(poly p, number n, ring r)
intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
#define pGetComp(p)
Component.
static poly p_Copy(poly p, const ring r)
returns a copy of p
ideal idMinBase(ideal h1)
matrix idCoeffOfKBase(ideal arg, ideal kbase, poly how)
int pWeight(int i, const ring R=currRing)
static poly p_Copy_noCheck(poly p, const ring r)
returns a copy of p (without any additional testing)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
void id_Shift(ideal M, int s, const ring r)
static poly p_Head(poly p, const ring r)
long p_DegW(poly p, const short *w, const ring R)
static ideal idInitializeQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN *addOnlyOne, int *kkmax)
ideal idSect(ideal h1, ideal h2)
long p_Deg(poly a, const ring r)
Coefficient rings, fields and other domains suitable for Singular polynomials.
ideal idSeries(int n, ideal M, matrix U, intvec *w)
ideal idElimination(ideal h1, poly delVar, intvec *hilb)
poly p_Farey(poly p, number N, const ring r)
void id_DelMultiples(ideal id, const ring r)
ideal id = (id[i]), c any unit if id[i] = c*id[j] then id[j] is deleted for j > i ...
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
intvec * idMWLift(ideal mod, intvec *weights)
const CanonicalForm CFMap CFMap & N
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
END_NAMESPACE BEGIN_NAMESPACE_SINGULARXX ideal poly int syzComp
ideal idMinors(matrix a, int ar, ideal R)
compute all ar-minors of the matrix a the caller of mpRecMin the elements of the result are not in R ...
ideal idFreeModule(int i)
double(* wFunctional)(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
ideal idSectWithElim(ideal h1, ideal h2)
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
ring rAssure_dp_C(const ring r)
static int pCompare(const poly a, const poly b)
void idSort_qsort(poly_sort *id_sort, int idsize)
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
static int p_LmCmp(poly p, poly q, const ring r)
void idGetNextChoise(int r, int end, BOOLEAN *endch, int *choise)
static int si_max(const int a, const int b)
void PrintS(const char *s)
static long p_MinComp(poly p, ring lmRing, ring tailRing)
ideal idCreateSpecialKbase(ideal kBase, intvec **convert)
static poly p_LmFreeAndNext(poly p, ring)
BOOLEAN idIsSubModule(ideal id1, ideal id2)
resolvente sySchreyerResolvente(ideal arg, int maxlength, int *length, BOOLEAN isMonomial=FALSE, BOOLEAN notReplace=FALSE)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static poly pReverse(poly p)
static int index(p_Length length, p_Ord ord)
void rSetSyzComp(int k, const ring r)
void rChangeCurrRing(ring r)
poly id_GCD(poly f, poly g, const ring r)
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
matrix mpNew(int r, int c)
create a r x c zero-matrix
#define TEST_OPT_RETURN_SB
static void p_Delete(poly *p, const ring r)
ideal idMult(ideal h1, ideal h2)
hh := h1 * h2
matrix mp_MultP(matrix a, poly p, const ring R)
multiply a matrix 'a' by a poly 'p', destroy the args
#define SI_RESTORE_OPT2(A)
ideal idInit(int idsize, int rank)
initialise an ideal / module
#define pSeries(n, p, u, w)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
poly p_DivideM(poly a, poly b, const ring r)
char name(const Variable &v)
static BOOLEAN rField_is_Ring(const ring r)
BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
static ideal idPrepare(ideal h1, tHomog hom, int syzcomp, intvec **w)
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
ideal id_Farey(ideal x, number N, const ring r)
void pEnlargeSet(poly **p, int l, int increment)
void wCall(poly *s, int sl, int *x, double wNsqr, const ring R)
BOOLEAN rHasGlobalOrdering(const ring r)
void rDelete(ring r)
unconditionally deletes fields in r
void pTakeOutComp(poly *p, long comp, poly *q, int *lq, const ring R=currRing)
Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other ...
void sm_KillModifiedRing(ring r)
static void idDeleteComps(ideal arg, int *red_comp, int del)
ideal kMin_std(ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb, int syzComp, int reduced)
ideal idLiftStd(ideal h1, matrix *ma, tHomog hi, ideal *syz)
void idInitChoise(int r, int beg, int end, BOOLEAN *endch, int *choise)
poly mp_DetBareiss(matrix a, const ring r)
returns the determinant of the matrix m; uses Bareiss algorithm
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit)
static void p_Setm(poly p, const ring r)
void syGaussForOne(ideal syz, int elnum, int ModComp, int from, int till)
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
static nc_type & ncRingType(nc_struct *p)
ideal idXXX(ideal h1, int k)
#define TEST_V_INTERSECT_SYZ
poly prMoveR_NoSort(poly &p, ring src_r, ring dest_r)
static poly p_Neg(poly p, const ring r)
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
int id_ReadOutPivot(ideal arg, int *comp, const ring r)
static poly p_Add_q(poly p, poly q, const ring r)
BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r)
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
#define SI_RESTORE_OPT1(A)
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
ideal id_Matrix2Module(matrix mat, const ring R)
BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
void Werror(const char *fmt,...)
void idDelete(ideal *h)
delete an ideal
ideal kGroebner(ideal F, ideal Q)
double wFunctionalBuch(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
#define pCopy(p)
return a copy of the poly
#define MATELEM(mat, i, j)