347 ring
rDefault(
int ch,
int N,
char **
n,
int ord_size,
int *ord,
int *block0,
int *block1,
int **wvhdl=
NULL);
348 ring
rDefault(
const coeffs cf,
int N,
char **
n,
int ord_size,
int *ord,
int *block0,
int *block1,
int **wvhdl=
NULL);
366 return (r !=
NULL) && ((n=r->GetNC()) !=
NULL) ;
378 && (r->real_var_start>1);
403 int rSum(ring r1, ring r2, ring &sum);
446 #define rField_is_Ring(A) (0)
447 #define rField_is_Ring_2toM(A) (0)
448 #define rField_is_Ring_ModN(A) (0)
449 #define rField_is_Ring_PtoM(A) (0)
450 #define rField_is_Ring_Z(A) (0)
451 #define rField_is_Domain(A) (1)
452 #define rField_has_Units(A) (1)
520 while (r->order[i]!=0) i++;
540 static inline short rVar(
const ring
r)
547 static inline int rPar(
const ring
r)
600 static inline number
n_Param(
const short iParameter,
const ring
r)
659 assume((!((C->extRing)->qideal==
NULL)) && (!idIs0((C->extRing)->qideal)));
737 ring
rAssure_TDeg(
const ring
r,
int start_var,
int end_var,
int &pos);
759 #define rHasGlobalOrdering_currRing() rHasGlobalOrdering(currRing)
760 #define rHasLocalOrMixedOrdering_currRing() rHasLocalOrMixedOrdering(currRing)
781 #define rTest(r) rDBTest(r, __FILE__, __LINE__)
789 unsigned long exp_limit);
817 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)
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 FORCE_INLINE BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
BOOLEAN rCheckIV(intvec *iv)
ring rAssure_c_dp(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
static BOOLEAN rShortOut(const ring r)
const CanonicalForm CFMap CFMap int &both_non_zero int n
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)
const nc_struct * GetNC() const
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
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
static bool rIsPluralRing(const ring r)
we must always have this test!
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)
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.
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.
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...
int rTypeOfMatrixOrder(intvec *order)
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)
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 bool rIsRatGRing(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...
int64 * rGetWeightVec(ring r)
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)