 |
My Project
UNKNOWN_GIT_VERSION
|
Go to the documentation of this file.
244 typedef poly (*
NF_Proc)(ideal, ideal, poly, int, int,
const ring _currRing);
385 unsigned long rGetExpSize(
unsigned long bitmask,
int & bits,
int N);
403 return ((n=r->GetNC()) !=
NULL) ;
425 && (r->real_var_start>1);
447 int rSum(ring r1, ring r2, ring &sum);
484 #define rField_is_Ring(A) (0)
485 #define rField_is_Ring_2toM(A) (0)
486 #define rField_is_Ring_PtoM(A) (0)
487 #define rField_is_Domain(A) (1)
488 #define rField_has_Units(A) (1)
562 while (r->order[
i]!=0)
i++;
582 static inline short rVar(
const ring r)
589 static inline int rPar(
const ring r)
642 static inline number
n_Param(
const short iParameter,
const ring r)
701 assume((!((C->extRing)->qideal==
NULL)) && (!
idIs0((C->extRing)->qideal)));
776 #define rTest(r) rDBTest(r, __FILE__, __LINE__)
779 #define rTest(r) (TRUE)
784 unsigned long exp_limit);
811 poly
rGetVar(
const int varIndex,
const ring r);
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
BOOLEAN rHasGlobalOrdering(const ring r)
static BOOLEAN rField_is_Zn(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
static BOOLEAN rField_is_long_R(const ring r)
ring rAssure_dp_S(const ring r)
void rSetWeightVec(ring r, int64 *wv)
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
long(* pLDegProc)(poly p, int *length, ring r)
void p_SetGlobals(const ring r, BOOLEAN complete=TRUE)
set all properties of a new ring - also called by rComplete
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
unsigned long rGetExpSize(unsigned long bitmask, int &bits, int N)
static BOOLEAN rCanShortOut(const ring r)
static BOOLEAN rField_is_Domain(const ring r)
static BOOLEAN rField_is_Ring_2toM(const ring r)
BOOLEAN rIsPolyVar(int i, const ring r)
returns TRUE if var(i) belongs to p-block
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
ring rCopy0AndAddA(ring r, int64vec *wv64, BOOLEAN copy_qideal=TRUE, BOOLEAN copy_ordering=TRUE)
void p_DebugPrint(poly p, const ring r)
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
long(* pFDegProc)(poly p, ring r)
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
@ rOrderType_Schreyer
Schreyer ordering.
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
static BOOLEAN length(leftv result, leftv arg)
rRingOrder_t rOrderName(char *ordername)
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr=TRUE)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
BOOLEAN rRing_has_CompLastBlock(ring r)
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit)
@ rOrderType_General
non-simple ordering as specified by currRing
BOOLEAN rHasTDeg(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...
const CanonicalForm CFMap CFMap & N
static BOOLEAN rField_is_Zp_a(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
ideal qideal
extension to the ring structure: qring, rInit, OR for Q_a/Zp_a, rInit (replaces minideal!...
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
ring rModifyRing_Simple(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit, BOOLEAN &simple)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
char * rCharStr(ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
static BOOLEAN rField_has_Units(const ring r)
int rTypeOfMatrixOrder(const intvec *order)
void pISUpdateComponents(ideal F, const intvec *const V, const int MIN, const ring r)
int64 * rGetWeightVec(const ring 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...
int rSum(ring r1, ring r2, ring &sum)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static int rGetCurrSyzLimit(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
@ rOrderType_Exp
simple ordering, exponent vector has priority component is compatible with exp-vector order
BOOLEAN rCheckIV(const intvec *iv)
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
static short rVar(const ring r)
#define rVar(r) (r->N)
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
rOrderType_t rGetOrderType(ring r)
static BOOLEAN rField_is_Q_a(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
@ rOrderType_CompExp
simple ordering, component has priority
static char * rRingVar(short i, const ring r)
ring rAssure_dp_C(const ring r)
ideal(* BBA_Proc)(const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring)
static BOOLEAN rField_is_Ring(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_TDeg(const ring r, int &pos)
ring rAssure_CompLastBlock(const ring r, BOOLEAN complete=TRUE)
makes sure that c/C ordering is last ordering
ring rDefault(int ch, int N, char **n)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
static BOOLEAN rIsRatGRing(const ring r)
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
int rGetISPos(const int p, const ring r)
return the position of the p^th IS block order block in r->typ[]...
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
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,...
ring rModifyRing_Wp(ring r, int *weights)
construct Wp, C ring
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
static BOOLEAN rField_is_Ring_PtoM(const ring r)
void rKillModifiedRing(ring r)
BOOLEAN rDBTest(ring r, const char *fn, const int l)
void rSetSyzComp(int k, const ring r)
@ rOrderType_Syz
syzygy ordering
static int rPar(const ring r)
(r->cf->P)
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
ring rAssure_C_dp(const ring r)
struct p_Procs_s p_Procs_s
static BOOLEAN rField_is_R(const ring r)
poly rGetVar(const int varIndex, const ring r)
static int rBlocks(ring r)
void rWrite(ring r, BOOLEAN details=FALSE)
static BOOLEAN rMinpolyIsNULL(const ring r)
Tests whether '(r->cf->minpoly) == NULL'.
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,...
ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete=TRUE, int sgn=1)
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
BOOLEAN rHasSimpleOrder(const ring r)
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
ring rAssure_HasComp(const ring r)
n_coeffType rFieldType(const ring r)
void rKillModified_Wp_Ring(ring r)
@ rOrderType_ExpNoComp
simple ordering, differences in component are not considered
static BOOLEAN rIsNCRing(const ring r)
static BOOLEAN rField_is_numeric(const ring r)
static BOOLEAN rField_is_GF(const ring r)
The following sip_sideal structure has many different uses thoughout Singular. Basic use-cases for it...
void rDelete(ring r)
unconditionally deletes fields in r
ring rCopy0(const ring r, BOOLEAN copy_qideal=TRUE, BOOLEAN copy_ordering=TRUE)
void rDebugPrint(const ring r)
@ ringorder_IS
Induced (Schreyer) ordering.
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
static BOOLEAN rOrd_is_Comp_dp(const ring r)
poly(* NF_Proc)(ideal, ideal, poly, int, int, const ring _currRing)
static BOOLEAN rField_has_simple_inverse(const ring r)
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
ring rAssure_SyzComp_CompLastBlock(const ring r)
makes sure that c/C ordering is last ordering and SyzIndex is first
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
BOOLEAN rHasSimpleLexOrder(const ring r)
returns TRUE, if simple lp or ls ordering
int n_IsParam(number m, const ring r)
if m == var(i)/1 => return i,
ring rAssure_SyzComp(const ring r, BOOLEAN complete=TRUE)
void(* p_SetmProc)(poly p, const ring r)
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 r_IsRingVar(const char *n, char **names, int N)
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
const nc_struct * GetNC() const
const char * rSimpleOrdStr(int ord)
static BOOLEAN rIsSyzIndexRing(const ring r)
BOOLEAN rRing_is_Homog(ring r)
BOOLEAN rHas_c_Ordering(const ring r)
@ ringorder_rs
opposite of ls
@ ringorder_a64
for int64 weights
BOOLEAN rHasMixedOrdering(const ring r)
static char const ** rParameter(const ring r)
(r->cf->parameter)
static BOOLEAN rField_is_Z(const ring r)
static BOOLEAN rField_is_long_C(const ring r)
@ rOrderType_Syz2dpc
syzcomp2dpc
static BOOLEAN rField_is_Zp(const ring r)
static BOOLEAN rShortOut(const ring r)
ring rAssure_c_dp(const ring r)
long * currShiftedComponents
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
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.
int sgn(const Rational &a)
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)
static BOOLEAN rField_is_Q(const ring r)
void rModify_a_to_A(ring r)
static int rInternalChar(const ring r)