378 inline const nc_struct*
GetNC()
const {
return _nc; };
379 inline nc_struct*&
GetNC() {
return _nc; };
390 ring
rDefault(
int ch,
int N,
char **n,
int ord_size,
int *ord,
int *block0,
int *block1,
int **wvhdl=
NULL);
391 ring
rDefault(
const coeffs cf,
int N,
char **n,
int ord_size,
int *ord,
int *block0,
int *block1,
int **wvhdl=
NULL);
409 return (r !=
NULL) && ((n=r->GetNC()) !=
NULL) ;
421 && (r->real_var_start>1);
443 int rSum(ring r1, ring r2, ring &sum);
486 #define rField_is_Ring(A) (0) 487 #define rField_is_Ring_2toM(A) (0) 488 #define rField_is_Ring_ModN(A) (0) 489 #define rField_is_Ring_PtoM(A) (0) 490 #define rField_is_Ring_Z(A) (0) 491 #define rField_is_Domain(A) (1) 492 #define rField_has_Units(A) (1) 560 while (r->order[i]!=0) i++;
580 static inline short rVar(
const ring
r)
587 static inline int rPar(
const ring
r)
640 static inline number
n_Param(
const short iParameter,
const ring
r)
699 assume((!((C->extRing)->qideal==
NULL)) && (!idIs0((C->extRing)->qideal)));
731 ring
rAssure_TDeg(
const ring
r,
int start_var,
int end_var,
int &pos);
753 #define rHasGlobalOrdering_currRing() rHasGlobalOrdering(currRing) 754 #define rHasLocalOrMixedOrdering_currRing() rHasLocalOrMixedOrdering(currRing) 775 #define rTest(r) rDBTest(r, __FILE__, __LINE__) 778 #define rTest(r) (TRUE) 783 unsigned long exp_limit);
811 poly
rGetVar(
const int varIndex,
const ring
r);
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
BOOLEAN rSetISReference(const ring r, const ideal F, const int i=0, const int p=0)
Changes r by setting induced ordering parameters: limit and reference leading terms F belong to r...
char * rCharStr(ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar...
for idElimination, like a, except pFDeg, pWeigths ignore it
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
ring rModifyRing_Simple(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit, BOOLEAN &simple)
poly(* NF_Proc)(ideal, ideal, poly, int, int, const ring _currRing)
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
const char * rSimpleOrdStr(int ord)
BOOLEAN rRing_is_Homog(ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_ModN(const coeffs r)
ring rAssure_dp_C(const ring r)
ideal(* BBA_Proc)(const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring)
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
const nc_struct * GetNC() const
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
BOOLEAN rComplete(ring r, int force=0)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
ring rAssure_CompLastBlock(const ring r, BOOLEAN complete=TRUE)
makes sure that c/C ordering is last ordering
void rDelete(ring r)
unconditionally deletes fields in r
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
non-simple ordering as specified by currRing
simple ordering, exponent vector has priority < component is compatible with exp-vector order ...
static BOOLEAN rField_is_Zp_a(const ring r)
static BOOLEAN rField_is_Ring_PtoM(const ring r)
void rSetSyzComp(int k, const ring r)
static int rPar(const ring r)
(r->cf->P)
static BOOLEAN rField_is_Ring_ModN(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
static BOOLEAN rIsSyzIndexRing(const ring r)
struct p_Procs_s p_Procs_s
static BOOLEAN rField_is_R(const ring r)
static int rGetCurrSyzLimit(const ring r)
static BOOLEAN rIsRatGRing(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
ring rAssure_c_dp(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
static BOOLEAN rShortOut(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
static short rVar(const ring r)
#define rVar(r) (r->N)
int n_IsParam(number m, const ring r)
if m == var(i)/1 => return i,
static FORCE_INLINE BOOLEAN nCoeff_has_simple_inverse(const coeffs r)
TRUE, if the computation of the inverse is fast, i.e. prefer leading coeff. 1 over content...
BOOLEAN rDBTest(ring r, const char *fn, const int l)
ring rAssure_SyzComp_CompLastBlock(const ring r, BOOLEAN complete=TRUE)
makes sure that c/C ordering is last ordering and SyzIndex is first
int r_IsRingVar(const char *n, char **names, int N)
static BOOLEAN rField_is_Q_a(const ring r)
static BOOLEAN rField_is_Domain(const ring r)
void rKillModified_Wp_Ring(ring r)
simple ordering, component has priority
BOOLEAN rHas_c_Ordering(const ring r)
ring rCopy0AndAddA(ring r, int64vec *wv64, BOOLEAN copy_qideal=TRUE, BOOLEAN copy_ordering=TRUE)
static BOOLEAN rField_is_GF(const ring r)
static char const ** rParameter(const ring r)
(r->cf->parameter)
long * currShiftedComponents
void rDebugPrint(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
int rGetISPos(const int p, const ring r)
return the position of the p^th IS block order block in r->typ[]...
long(* pLDegProc)(poly p, int *length, ring r)
static BOOLEAN rCanShortOut(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
ring rModifyRing_Wp(ring r, int *weights)
construct Wp, C ring
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
void rKillModifiedRing(ring r)
simple ordering, exponent vector has priority < component not compatible with exp-vector order ...
static BOOLEAN rField_has_simple_inverse(const ring r)
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
ring rAssure_HasComp(const ring r)
n_coeffType rFieldType(const ring r)
static int rBlocks(ring r)
static BOOLEAN rMinpolyIsNULL(const ring r)
Tests whether '(r->cf->minpoly) == NULL'.
Coefficient rings, fields and other domains suitable for Singular polynomials.
ring rAssure_dp_S(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
const CanonicalForm CFMap CFMap & N
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit)
The main handler for Singular numbers which are suitable for Singular polynomials.
BOOLEAN rCheckIV(const intvec *iv)
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
int64 * rGetWeightVec(const ring r)
BOOLEAN rHasSimpleLexOrder(const ring r)
returns TRUE, if simple lp or ls ordering
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
int rSum(ring r1, ring r2, ring &sum)
Induced (Schreyer) ordering.
static char * rRingVar(short i, const ring r)
void(* p_SetmProc)(poly p, const ring r)
static BOOLEAN rField_is_Q(const ring r)
ring rAssure_TDeg(const ring r, int start_var, int end_var, int &pos)
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
BOOLEAN rHasMixedOrdering(const ring r)
static BOOLEAN rField_is_long_C(const ring r)
static BOOLEAN rField_is_Zp(const ring r)
ring rAssure_SyzComp(const ring r, BOOLEAN complete=TRUE)
poly(* pShallowCopyDeleteProc)(poly s_p, ring source_r, ring dest_r, omBin dest_bin)
returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == de...
The following sip_sideal structure has many different uses thoughout Singular. Basic use-cases for it...
static BOOLEAN rField_is_Ring_2toM(const ring r)
static BOOLEAN rField_is_Ring(const ring r)
void rKillModifiedRing_Simple(ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
ring rDefault(int ch, int N, char **n)
BOOLEAN rHasGlobalOrdering(const ring r)
long(* pFDegProc)(poly p, ring r)
static BOOLEAN rField_is_Ring_Z(const ring r)
static BOOLEAN rField_is_long_R(const ring r)
rOrderType_t rGetOrderType(ring r)
ideal qideal
extension to the ring structure: qring, rInit, OR for Q_a/Zp_a, rInit (replaces minideal!); for a sta...
int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering, 1: dp,dp, 2: aa(...),dp vartest: check for name conflicts
BOOLEAN rHasSimpleOrder(const ring r)
void rSetWeightVec(ring r, int64 *wv)
ring rAssure_C_dp(const ring r)
BOOLEAN rIsPolyVar(int i, const ring r)
returns TRUE if var(i) belongs to p-block
poly rGetVar(const int varIndex, const ring r)
void rModify_a_to_A(ring r)
static int rInternalChar(const ring r)
BOOLEAN rRing_has_CompLastBlock(ring r)
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
void p_DebugPrint(poly p, const ring r)
static BOOLEAN rField_has_Units(const ring r)
static BOOLEAN rOrd_is_Comp_dp(const ring r)
int rOrderName(char *ordername)
int rTypeOfMatrixOrder(const intvec *order)
simple ordering, differences in component are < not considered
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
void p_SetGlobals(const ring r, BOOLEAN complete=TRUE)
set all properties of a new ring - also called by rComplete
static BOOLEAN rField_is_numeric(const ring r)
static number n_Param(const short iParameter, const ring r)
return the specified parameter as a (new!) number in the given polynomial ring, or NULL if invalid pa...
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr=TRUE)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise, if qr == 1, then qrideal equality is tested, as well
void rWrite(ring r, BOOLEAN details=FALSE)
ring rCopy0(const ring r, BOOLEAN copy_qideal=TRUE, BOOLEAN copy_ordering=TRUE)