My Project
Loading...
Searching...
No Matches
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
ring.h File Reference
#include "misc/auxiliary.h"
#include "coeffs/coeffs.h"
#include "misc/intvec.h"
#include "misc/int64vec.h"
#include "polys/monomials/monomials.h"

Go to the source code of this file.

Data Structures

struct  sro_dp
 
struct  sro_wp
 
struct  sro_am
 
struct  sro_wp64
 
struct  sro_cp
 
struct  sro_syzcomp
 
struct  sro_syz
 
struct  sro_ISTemp
 
struct  sro_IS
 
struct  sro_ord
 
struct  ring
 
union  sro_ord.data
 

Macros

#define rField_is_Ring(R)   nCoeff_is_Ring((R)->cf)
 
#define rTest(r)   rDBTest(r, __FILE__, __LINE__)
 

Typedefs

typedef idrecidhdl
 
typedef struct p_Procs_s p_Procs_s
 
typedef kBucketkBucket_pt
 
typedef long(* pLDegProc) (poly p, int *length, ring r)
 
typedef long(* pFDegProc) (poly p, ring r)
 
typedef void(* p_SetmProc) (poly p, const ring r)
 
typedef 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 == dest_r->N and that orderings are the same
 
typedef skStrategykStrategy
 
typedef poly(* NF_Proc) (ideal, ideal, poly, int, int, const ring _currRing)
 
typedef ideal(* BBA_Proc) (const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring)
 

Enumerations

enum  ro_typ {
  ro_dp , ro_wp , ro_am , ro_wp64 ,
  ro_wp_neg , ro_cp , ro_syzcomp , ro_syz ,
  ro_isTemp , ro_is , ro_none
}
 
enum  rRingOrder_t {
  ringorder_no = 0 , ringorder_a , ringorder_a64 , ringorder_c ,
  ringorder_C , ringorder_M , ringorder_S , ringorder_s ,
  ringorder_lp , ringorder_dp , ringorder_rp , ringorder_Dp ,
  ringorder_wp , ringorder_Wp , ringorder_ls , ringorder_ds ,
  ringorder_Ds , ringorder_ws , ringorder_Ws , ringorder_am ,
  ringorder_L , ringorder_aa , ringorder_rs , ringorder_IS ,
  ringorder_unspec
}
 order stuff More...
 
enum  rOrderType_t {
  rOrderType_General = 0 , rOrderType_CompExp , rOrderType_ExpComp , rOrderType_Exp ,
  rOrderType_Syz , rOrderType_Schreyer , rOrderType_Syz2dpc , rOrderType_ExpNoComp
}
 

Functions

ring rDefault (int ch, int N, char **n)
 
ring rDefault (const coeffs cf, int N, char **n, const rRingOrder_t o=ringorder_lp)
 
ring rDefault (int ch, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl=NULL)
 
ring rDefault (const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl=NULL, unsigned long bitmask=0)
 
unsigned long rGetExpSize (unsigned long bitmask, int &bits, int N)
 
int r_IsRingVar (const char *n, char **names, int N)
 
void rWrite (ring r, BOOLEAN details=FALSE)
 
ring rCopy (ring r)
 
ring rCopy0 (const ring r, BOOLEAN copy_qideal=TRUE, BOOLEAN copy_ordering=TRUE)
 
ring rCopy0AndAddA (ring r, int64vec *wv64, BOOLEAN copy_qideal=TRUE, BOOLEAN copy_ordering=TRUE)
 
ring rOpposite (ring r)
 
ring rEnvelope (ring r)
 
static BOOLEAN rIsPluralRing (const ring r)
 we must always have this test!
 
static BOOLEAN rIsLPRing (const ring r)
 
static BOOLEAN rIsNCRing (const ring r)
 
static BOOLEAN rIsRatGRing (const ring r)
 
void rChangeSComps (int *currComponents, long *currShiftedComponents, int length, ring r)
 
void rGetSComps (int **currComponents, long **currShiftedComponents, int *length, ring r)
 
const charrSimpleOrdStr (int ord)
 
rRingOrder_t rOrderName (char *ordername)
 
charrOrdStr (ring r)
 
charrVarStr (ring r)
 
charrCharStr (ring r)
 TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
 
charrString (ring r)
 
int rChar (ring r)
 
charrParStr (ring r)
 
int rSum (ring r1, ring r2, ring &sum)
 
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 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
 
BOOLEAN rSamePolyRep (ring r1, ring r2)
 returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analogue to rEqual but not so strict
 
void rUnComplete (ring r)
 
BOOLEAN rRing_has_CompLastBlock (const ring r)
 
BOOLEAN rRing_ord_pure_dp (const ring r)
 
BOOLEAN rRing_ord_pure_Dp (const ring r)
 
BOOLEAN rRing_ord_pure_lp (const ring r)
 
static BOOLEAN rField_is_Ring_2toM (const ring r)
 
static BOOLEAN rField_is_Ring_PtoM (const ring r)
 
static BOOLEAN rField_is_Domain (const ring r)
 
static BOOLEAN rField_has_Units (const ring r)
 
static BOOLEAN rField_is_Zp (const ring r)
 
static BOOLEAN rField_is_Zp (const ring r, int p)
 
static BOOLEAN rField_is_Q (const ring r)
 
static BOOLEAN rField_is_Z (const ring r)
 
static BOOLEAN rField_is_Zn (const ring r)
 
static BOOLEAN rField_is_numeric (const ring r)
 
static BOOLEAN rField_is_R (const ring r)
 
static BOOLEAN rField_is_GF (const ring r)
 
static BOOLEAN rField_is_GF (const ring r, int q)
 
static BOOLEAN rField_is_Zp_a (const ring r)
 
static BOOLEAN rField_is_Zp_a (const ring r, int p)
 
static BOOLEAN rField_is_Q_a (const ring r)
 
static BOOLEAN rField_is_long_R (const ring r)
 
static BOOLEAN rField_is_long_C (const ring r)
 
static BOOLEAN rField_has_simple_inverse (const ring r)
 
static BOOLEAN rField_has_simple_Alloc (const ring r)
 Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
 
static n_coeffType rFieldType (const ring r)
 the type of the coefficient filed of r (n_Zp, n_Q, etc)
 
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 VarOffset), unless they already exist with force == 1, new fields are always created (overwritten), even if they exist
 
void p_SetGlobals (const ring r, BOOLEAN complete=TRUE)
 set all properties of a new ring - also called by rComplete
 
static int rBlocks (const ring r)
 
static charrRingVar (short i, const ring r)
 
static BOOLEAN rShortOut (const ring r)
 
static BOOLEAN rCanShortOut (const ring r)
 
static short rVar (const ring r)
 #define rVar(r) (r->N)
 
static int rPar (const ring r)
 (r->cf->P)
 
static char const ** rParameter (const ring r)
 (r->cf->parameter)
 
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 parameters (as variables) begin with 1!
 
int n_IsParam (number m, const ring r)
 if m == var(i)/1 => return i,
 
static int rInternalChar (const ring r)
 
static BOOLEAN rMinpolyIsNULL (const ring r)
 Tests whether '(r->cf->minpoly) == NULL'.
 
static BOOLEAN rIsSyzIndexRing (const ring r)
 
static int rGetCurrSyzLimit (const ring r)
 
void rSetSyzComp (int k, const ring r)
 
ring rAssure_HasComp (const ring r)
 
ring rAssure_SyzOrder (const ring r, BOOLEAN complete)
 
ring rAssure_SyzComp (const ring r, BOOLEAN complete=TRUE)
 
ring rAssure_InducedSchreyerOrdering (const ring r, BOOLEAN complete=TRUE, int sgn=1)
 
ring rAssure_dp_S (const ring r)
 
ring rAssure_dp_C (const ring r)
 
ring rAssure_Dp_C (const ring r)
 
ring rAssure_Wp_C (const ring r, intvec *w)
 
ring rAssure_C_dp (const ring r)
 
ring rAssure_c_dp (const ring r)
 
ring rAssure_CompLastBlock (const ring r, BOOLEAN complete=TRUE)
 makes sure that c/C ordering is last ordering
 
ring rAssure_SyzComp_CompLastBlock (const ring r)
 makes sure that c/C ordering is last ordering and SyzIndex is first
 
ring rAssure_TDeg (const ring r, int &pos)
 
int rGetMaxSyzComp (int i, const ring r)
 return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
 
BOOLEAN rHasSimpleOrder (const ring r)
 
BOOLEAN rHas_c_Ordering (const ring r)
 
BOOLEAN rHasSimpleLexOrder (const ring r)
 returns TRUE, if simple lp or ls ordering
 
BOOLEAN rHasGlobalOrdering (const ring r)
 
BOOLEAN rHasLocalOrMixedOrdering (const ring r)
 
BOOLEAN rHasMixedOrdering (const ring r)
 
BOOLEAN rOrd_is_Totaldegree_Ordering (const ring r)
 
BOOLEAN rOrd_is_dp (const ring r)
 
BOOLEAN rOrd_SetCompRequiresSetm (const ring r)
 return TRUE if p_SetComp requires p_Setm
 
rOrderType_t rGetOrderType (ring r)
 
static BOOLEAN rOrd_is_Comp_dp (const ring r)
 
BOOLEAN rDBTest (ring r, const char *fn, const int l)
 
ring rModifyRing (ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit)
 
ring rModifyRing_Wp (ring r, int *weights)
 construct Wp, C ring
 
void rKillModifiedRing (ring r)
 
void rKillModified_Wp_Ring (ring r)
 
ring rModifyRing_Simple (ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit, BOOLEAN &simple)
 
void rDebugPrint (const ring r)
 
void p_DebugPrint (poly p, const ring r)
 
int64rGetWeightVec (const ring r)
 
void rSetWeightVec (ring r, int64 *wv)
 
poly rGetVar (const int varIndex, const ring r)
 
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, we will DO a copy! We will use it AS IS! returns true is everything was allright!
 
int rGetISPos (const int p, const ring r)
 return the position of the p^th IS block order block in r->typ[]...
 
BOOLEAN rCheckIV (const intvec *iv)
 
int rTypeOfMatrixOrder (const intvec *order)
 
void rDelete (ring r)
 unconditionally deletes fields in r
 
ring rPlusVar (const ring r, char *v, int left)
 K[x],"y" -> K[x,y] resp. K[y,x].
 
ring rMinusVar (const ring r, char *v)
 undo rPlusVar
 
static ring rIncRefCnt (ring r)
 
static void rDecRefCnt (ring r)
 

Variables

EXTERN_VAR omBin sip_sring_bin
 

Data Structure Documentation

◆ sro_dp

struct sro_dp

Definition at line 113 of file ring.h.

Data Fields
short end
short place
short start

◆ sro_wp

struct sro_wp

Definition at line 122 of file ring.h.

Data Fields
short end
short place
short start
int * weights

◆ sro_am

struct sro_am

Definition at line 132 of file ring.h.

Data Fields
short end
short len_gen
short place
short start
int * weights
int * weights_m

◆ sro_wp64

struct sro_wp64

Definition at line 147 of file ring.h.

Data Fields
short end
short place
short start
int64 * weights64

◆ sro_cp

struct sro_cp

Definition at line 157 of file ring.h.

Data Fields
short end
short place
short start

◆ sro_syzcomp

struct sro_syzcomp

Definition at line 166 of file ring.h.

Data Fields
int * Components
long length
short place
long * ShiftedComponents

◆ sro_syz

struct sro_syz

Definition at line 178 of file ring.h.

Data Fields
int curr_index
int limit
short place
int * syz_index

◆ sro_ISTemp

struct sro_ISTemp

Definition at line 194 of file ring.h.

Data Fields
int * pVarOffset
short start
int suffixpos

◆ sro_IS

struct sro_IS

Definition at line 204 of file ring.h.

Data Fields
short end
ideal F
int limit
int * pVarOffset
short start

◆ sro_ord

struct sro_ord

Definition at line 218 of file ring.h.

Data Fields
union sro_ord.data data
ro_typ ord_typ
int order_index

◆ sro_ord.data

union sro_ord.data

Definition at line 222 of file ring.h.

Data Fields
sro_am am
sro_cp cp
sro_dp dp
sro_IS is
sro_ISTemp isTemp
sro_syz syz
sro_syzcomp syzcomp
sro_wp wp
sro_wp64 wp64

Macro Definition Documentation

◆ rField_is_Ring

#define rField_is_Ring (   R)    nCoeff_is_Ring((R)->cf)

Definition at line 485 of file ring.h.

◆ rTest

#define rTest (   r)    rDBTest(r, __FILE__, __LINE__)

Definition at line 785 of file ring.h.

Typedef Documentation

◆ BBA_Proc

Definition at line 244 of file ring.h.

◆ idhdl

Definition at line 21 of file ring.h.

◆ kBucket_pt

Definition at line 25 of file ring.h.

◆ kStrategy

Definition at line 241 of file ring.h.

◆ NF_Proc

typedef poly(* NF_Proc) (ideal, ideal, poly, int, int, const ring _currRing)

Definition at line 243 of file ring.h.

◆ p_Procs_s

Definition at line 23 of file ring.h.

◆ p_SetmProc

typedef void(* p_SetmProc) (poly p, const ring r)

Definition at line 39 of file ring.h.

◆ pFDegProc

typedef long(* pFDegProc) (poly p, ring r)

Definition at line 38 of file ring.h.

◆ pLDegProc

typedef long(* pLDegProc) (poly p, int *length, ring r)

Definition at line 37 of file ring.h.

◆ pShallowCopyDeleteProc

typedef 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 == dest_r->N and that orderings are the same

Definition at line 44 of file ring.h.

Enumeration Type Documentation

◆ ro_typ

Enumerator
ro_dp 
ro_wp 
ro_am 
ro_wp64 
ro_wp_neg 
ro_cp 
ro_syzcomp 
ro_syz 
ro_isTemp 
ro_is 
ro_none 

Definition at line 50 of file ring.h.

51{
52 ro_dp, // total degree with weights 1
53 ro_wp, // total weighted degree with weights>0 in wvhdl
54 ro_am, // weights for vars + weights for gen
55 ro_wp64, // weighted64 degree weights in wvhdl
56 ro_wp_neg, // total weighted degree with weights in Z in wvhdl
57 // (with possibly negative weights)
58 ro_cp, // ??ordering duplicates variables
59 ro_syzcomp, // ??ordering indicates "subset" of component number (ringorder_S)
60 ro_syz, // component number if <=syzcomp else 0 (ringorder_s)
61 ro_isTemp, ro_is, // ??Induced Syzygy (Schreyer) ordering (and prefix data placeholder dummy) (ringorder_IS)
63}
@ ro_wp64
Definition ring.h:55
@ ro_syz
Definition ring.h:60
@ ro_cp
Definition ring.h:58
@ ro_dp
Definition ring.h:52
@ ro_is
Definition ring.h:61
@ ro_wp_neg
Definition ring.h:56
@ ro_wp
Definition ring.h:53
@ ro_isTemp
Definition ring.h:61
@ ro_am
Definition ring.h:54
@ ro_none
Definition ring.h:62
@ ro_syzcomp
Definition ring.h:59

◆ rOrderType_t

Enumerator
rOrderType_General 

non-simple ordering as specified by currRing

rOrderType_CompExp 

simple ordering, component has priority

rOrderType_ExpComp 

simple ordering, exponent vector has priority component not compatible with exp-vector order

rOrderType_Exp 

simple ordering, exponent vector has priority component is compatible with exp-vector order

rOrderType_Syz 

syzygy ordering

rOrderType_Schreyer 

Schreyer ordering.

rOrderType_Syz2dpc 

syzcomp2dpc

rOrderType_ExpNoComp 

simple ordering, differences in component are not considered

Definition at line 97 of file ring.h.

98{
99 rOrderType_General = 0, ///< non-simple ordering as specified by currRing
100 rOrderType_CompExp, ///< simple ordering, component has priority
101 rOrderType_ExpComp, ///< simple ordering, exponent vector has priority
102 ///< component not compatible with exp-vector order
103 rOrderType_Exp, ///< simple ordering, exponent vector has priority
104 ///< component is compatible with exp-vector order
105 rOrderType_Syz, ///< syzygy ordering
106 rOrderType_Schreyer, ///< Schreyer ordering
107 rOrderType_Syz2dpc, ///< syzcomp2dpc
108 rOrderType_ExpNoComp ///< simple ordering, differences in component are
109 ///< not considered
rOrderType_t
Definition ring.h:98
@ rOrderType_Syz
syzygy ordering
Definition ring.h:105
@ rOrderType_Syz2dpc
syzcomp2dpc
Definition ring.h:107
@ rOrderType_CompExp
simple ordering, component has priority
Definition ring.h:100
@ rOrderType_Exp
simple ordering, exponent vector has priority component is compatible with exp-vector order
Definition ring.h:103
@ rOrderType_General
non-simple ordering as specified by currRing
Definition ring.h:99
@ rOrderType_Schreyer
Schreyer ordering.
Definition ring.h:106
@ rOrderType_ExpNoComp
simple ordering, differences in component are not considered
Definition ring.h:108
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
Definition ring.h:101

◆ rRingOrder_t

order stuff

Enumerator
ringorder_no 
ringorder_a 
ringorder_a64 

for int64 weights

ringorder_c 
ringorder_C 
ringorder_M 
ringorder_S 

S?

ringorder_s 

s?

ringorder_lp 
ringorder_dp 
ringorder_rp 
ringorder_Dp 
ringorder_wp 
ringorder_Wp 
ringorder_ls 
ringorder_ds 
ringorder_Ds 
ringorder_ws 
ringorder_Ws 
ringorder_am 
ringorder_L 
ringorder_aa 

for idElimination, like a, except pFDeg, pWeigths ignore it

ringorder_rs 

opposite of ls

ringorder_IS 

Induced (Schreyer) ordering.

ringorder_unspec 

Definition at line 67 of file ring.h.

68{
69 ringorder_no = 0,
71 ringorder_a64, ///< for int64 weights
75 ringorder_S, ///< S?
76 ringorder_s, ///< s?
90 // the following are only used internally
91 ringorder_aa, ///< for idElimination, like a, except pFDeg, pWeigths ignore it
92 ringorder_rs, ///< opposite of ls
93 ringorder_IS, ///< Induced (Schreyer) ordering
rRingOrder_t
order stuff
Definition ring.h:68
@ ringorder_lp
Definition ring.h:77
@ ringorder_a
Definition ring.h:70
@ ringorder_am
Definition ring.h:88
@ ringorder_a64
for int64 weights
Definition ring.h:71
@ ringorder_rs
opposite of ls
Definition ring.h:92
@ ringorder_C
Definition ring.h:73
@ ringorder_S
S?
Definition ring.h:75
@ ringorder_ds
Definition ring.h:84
@ ringorder_Dp
Definition ring.h:80
@ ringorder_unspec
Definition ring.h:94
@ ringorder_L
Definition ring.h:89
@ ringorder_Ds
Definition ring.h:85
@ ringorder_dp
Definition ring.h:78
@ ringorder_c
Definition ring.h:72
@ ringorder_rp
Definition ring.h:79
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition ring.h:91
@ ringorder_no
Definition ring.h:69
@ ringorder_Wp
Definition ring.h:82
@ ringorder_ws
Definition ring.h:86
@ ringorder_Ws
Definition ring.h:87
@ ringorder_IS
Induced (Schreyer) ordering.
Definition ring.h:93
@ ringorder_ls
Definition ring.h:83
@ ringorder_s
s?
Definition ring.h:76
@ ringorder_wp
Definition ring.h:81
@ ringorder_M
Definition ring.h:74

Function Documentation

◆ n_IsParam()

int n_IsParam ( const number  m,
const ring  r 
)

if m == var(i)/1 => return i,

if m == var(i)/1 => return i,

Definition at line 5834 of file ring.cc.

5835{
5836 assume(r != NULL);
5837 const coeffs C = r->cf;
5838 assume(C != NULL);
5839
5841
5843
5844 if(( _filed_type == n_algExt )||( _filed_type == n_polyExt ))
5845 return naIsParam(m, C);
5846
5847 if( _filed_type == n_transExt )
5848 return ntIsParam(m, C);
5849
5850 Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C));
5851
5852 return 0;
5853}
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition algext.cc:1106
int m
Definition cfEzgcd.cc:128
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition coeffs.h:843
n_coeffType
Definition coeffs.h:27
@ n_polyExt
used to represent polys as coeffcients
Definition coeffs.h:34
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition coeffs.h:35
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition coeffs.h:422
#define assume(x)
Definition mod2.h:389
The main handler for Singular numbers which are suitable for Singular polynomials.
#define NULL
Definition omList.c:12
void Werror(const char *fmt,...)
Definition reporter.cc:189
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition transext.cc:2308

◆ n_Param()

static number n_Param ( const short  iParameter,
const ring  r 
)
inlinestatic

return the specified parameter as a (new!) number in the given polynomial ring, or NULL if invalid parameters (as variables) begin with 1!

Definition at line 652 of file ring.h.

653{
654 assume(r != NULL);
655 const coeffs C = r->cf;
656 assume(C != NULL);
657 return n_Param(iParameter, C);
658// const n_coeffType _filed_type = getCoeffType(C);
659//
660// if ( iParameter <= 0 || iParameter > rPar(r) )
661// // Wrong parameter
662// return NULL;
663//
664// if( _filed_type == n_algExt )
665// return naParameter(iParameter, C);
666//
667// if( _filed_type == n_transExt )
668// return ntParameter(iParameter, C);
669//
670// if (_filed_type == n_GF)// if (nCoeff_is_GF(C))
671// {
672// number nfPar (int i, const coeffs);
673// return nfPar(iParameter, C);
674// }
675//
676// if (_filed_type == n_long_C) // if (nCoeff_is_long_C(C))
677// {
678// number ngcPar(int i, const coeffs r);
679// return ngcPar(iParameter, C);
680// }
681//
682// return NULL;
683}
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...
Definition ring.h:652

◆ p_DebugPrint()

void p_DebugPrint ( poly  p,
const ring  r 
)

Definition at line 4336 of file ring.cc.

4337{
4338 int i,j;
4339 p_Write(p,r);
4340 j=2;
4341 while(p!=NULL)
4342 {
4343 Print("\nexp[0..%d]\n",r->ExpL_Size-1);
4344 for(i=0;i<r->ExpL_Size;i++)
4345 Print("%ld ",p->exp[i]);
4346 PrintLn();
4347 Print("v0:%ld ",p_GetComp(p, r));
4348 for(i=1;i<=r->N;i++) Print(" v%d:%ld",i,p_GetExp(p,i, r));
4349 PrintLn();
4350 pIter(p);
4351 j--;
4352 if (j==0) { PrintS("...\n"); break; }
4353 }
4354}
int i
Definition cfEzgcd.cc:132
int p
Definition cfModGcd.cc:4078
#define Print
Definition emacs.cc:80
int j
Definition facHensel.cc:110
#define p_GetComp(p, r)
Definition monomials.h:64
#define pIter(p)
Definition monomials.h:37
void p_Write(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:342
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition p_polys.h:469
void PrintS(const char *s)
Definition reporter.cc:284
void PrintLn()
Definition reporter.cc:310

◆ p_SetGlobals()

void p_SetGlobals ( const ring  r,
BOOLEAN  complete = TRUE 
)

set all properties of a new ring - also called by rComplete

Definition at line 3424 of file ring.cc.

3425{
3426// // // if (r->ppNoether!=NULL) p_Delete(&r->ppNoether,r); // ???
3427
3428 r->pLexOrder=r->LexOrder;
3429 if (complete)
3430 {
3432 si_opt_1 |= r->options;
3433 }
3434}
VAR unsigned si_opt_1
Definition options.c:5

◆ r_IsRingVar()

int r_IsRingVar ( const char n,
char **  names,
int  N 
)

Definition at line 212 of file ring.cc.

213{
214 if (names!=NULL)
215 {
216 for (int i=0; i<N; i++)
217 {
218 if (names[i]==NULL) return -1;
219 if (strcmp(n,names[i]) == 0) return (int)i;
220 }
221 }
222 return -1;
223}
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56

◆ rAssure_C_dp()

ring rAssure_C_dp ( const ring  r)

Definition at line 5046 of file ring.cc.

5047{
5049}
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
Definition ring.cc:4813

◆ rAssure_c_dp()

ring rAssure_c_dp ( const ring  r)

Definition at line 5051 of file ring.cc.

5052{
5054}

◆ rAssure_CompLastBlock()

ring rAssure_CompLastBlock ( const ring  r,
BOOLEAN  complete = TRUE 
)

makes sure that c/C ordering is last ordering

Definition at line 4703 of file ring.cc.

4704{
4705 int last_block = rBlocks(r) - 2;
4706 if (r->order[last_block] != ringorder_c &&
4707 r->order[last_block] != ringorder_C)
4708 {
4709 int c_pos = 0;
4710 int i;
4711
4712 for (i=0; i< last_block; i++)
4713 {
4714 if (r->order[i] == ringorder_c || r->order[i] == ringorder_C)
4715 {
4716 c_pos = i;
4717 break;
4718 }
4719 }
4720 if (c_pos != -1)
4721 {
4722 ring new_r = rCopy0(r, FALSE, TRUE);
4723 for (i=c_pos+1; i<=last_block; i++)
4724 {
4725 new_r->order[i-1] = new_r->order[i];
4726 new_r->block0[i-1] = new_r->block0[i];
4727 new_r->block1[i-1] = new_r->block1[i];
4728 new_r->wvhdl[i-1] = new_r->wvhdl[i];
4729 }
4730 new_r->order[last_block] = r->order[c_pos];
4731 new_r->block0[last_block] = r->block0[c_pos];
4732 new_r->block1[last_block] = r->block1[c_pos];
4733 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4734 if (complete)
4735 {
4736 rComplete(new_r, 1);
4737
4738#ifdef HAVE_PLURAL
4739 if (rIsPluralRing(r))
4740 {
4741 if ( nc_rComplete(r, new_r, false) ) // no qideal!
4742 {
4743#ifndef SING_NDEBUG
4744 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4745#endif
4746 }
4747 }
4749#endif
4750 }
4751 return new_r;
4752 }
4753 }
4754 return r;
4755}
#define TRUE
Definition auxiliary.h:100
#define FALSE
Definition auxiliary.h:96
#define WarnS
Definition emacs.cc:78
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...
Definition ring.cc:3459
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition ring.cc:5746
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition ring.cc:1421
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:400
static int rBlocks(const ring r)
Definition ring.h:568

◆ rAssure_dp_C()

ring rAssure_dp_C ( const ring  r)

Definition at line 5036 of file ring.cc.

5037{
5039}

◆ rAssure_Dp_C()

ring rAssure_Dp_C ( const ring  r)

Definition at line 5041 of file ring.cc.

5042{
5044}

◆ rAssure_dp_S()

ring rAssure_dp_S ( const ring  r)

Definition at line 5031 of file ring.cc.

5032{
5034}

◆ rAssure_HasComp()

ring rAssure_HasComp ( const ring  r)

Definition at line 4634 of file ring.cc.

4635{
4636 int last_block;
4637 int i=0;
4638 do
4639 {
4640 if (r->order[i] == ringorder_c ||
4641 r->order[i] == ringorder_C) return r;
4642 if (r->order[i] == 0)
4643 break;
4644 i++;
4645 } while (1);
4646 //WarnS("re-creating ring with comps");
4647 last_block=i-1;
4648
4649 ring new_r = rCopy0(r, FALSE, FALSE);
4650 i+=2;
4651 new_r->wvhdl=(int **)omAlloc0(i * sizeof(int *));
4652 new_r->order = (rRingOrder_t *) omAlloc0(i * sizeof(rRingOrder_t));
4653 new_r->block0 = (int *) omAlloc0(i * sizeof(int));
4654 new_r->block1 = (int *) omAlloc0(i * sizeof(int));
4655 memcpy(new_r->order,r->order,(i-1) * sizeof(rRingOrder_t));
4656 memcpy(new_r->block0,r->block0,(i-1) * sizeof(int));
4657 memcpy(new_r->block1,r->block1,(i-1) * sizeof(int));
4658 for (int j=0; j<=last_block; j++)
4659 {
4660 if (r->wvhdl[j]!=NULL)
4661 {
4662 #ifdef HAVE_OMALLOC
4663 new_r->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
4664 #else
4665 {
4666 int l=r->block1[j]-r->block0[j]+1;
4667 if (r->order[j]==ringorder_a64) l*=2;
4668 else if (r->order[j]==ringorder_M) l=l*l;
4669 else if (r->order[j]==ringorder_am)
4670 {
4671 l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
4672 }
4673 new_r->wvhdl[j]=(int*)omalloc(l*sizeof(int));
4674 memcpy(new_r->wvhdl[j],r->wvhdl[j],l*sizeof(int));
4675 }
4676 #endif
4677 }
4678 }
4679 last_block++;
4681 //new_r->block0[last_block]=0;
4682 //new_r->block1[last_block]=0;
4683 //new_r->wvhdl[last_block]=NULL;
4684
4685 rComplete(new_r, 1);
4686
4687#ifdef HAVE_PLURAL
4688 if (rIsPluralRing(r))
4689 {
4690 if ( nc_rComplete(r, new_r, false) ) // no qideal!
4691 {
4692#ifndef SING_NDEBUG
4693 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4694#endif
4695 }
4696 }
4698#endif
4699
4700 return new_r;
4701}
int l
Definition cfEzgcd.cc:100
#define omalloc(size)
#define omAlloc0(size)
#define omMemDup(s)

◆ rAssure_InducedSchreyerOrdering()

ring rAssure_InducedSchreyerOrdering ( const ring  r,
BOOLEAN  complete = TRUE,
int  sgn = 1 
)

Definition at line 4906 of file ring.cc.

4907{ // TODO: ???? Add leading Syz-comp ordering here...????
4908
4909#if MYTEST
4910 Print("rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
4911 rWrite(r);
4912#ifdef RDEBUG
4913 rDebugPrint(r);
4914#endif
4915 PrintLn();
4916#endif
4917 assume((sgn == 1) || (sgn == -1));
4918
4919 ring res=rCopy0(r, FALSE, FALSE); // No qideal & ordering copy.
4920
4921 int n = rBlocks(r); // Including trailing zero!
4922
4923 // Create 2 more blocks for prefix/suffix:
4924 res->order=(rRingOrder_t *)omAlloc0((n+2)*sizeof(rRingOrder_t)); // 0 .. n+1
4925 res->block0=(int *)omAlloc0((n+2)*sizeof(int));
4926 res->block1=(int *)omAlloc0((n+2)*sizeof(int));
4927 int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
4928
4929 // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
4930 // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
4931
4932 // new 1st block
4933 int j = 0;
4934 res->order[j] = ringorder_IS; // Prefix
4935 res->block0[j] = res->block1[j] = 0;
4936 // wvhdl[j] = NULL;
4937 j++;
4938
4939 for(int i = 0; (i <= n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
4940 {
4941 res->order [j] = r->order [i];
4942 res->block0[j] = r->block0[i];
4943 res->block1[j] = r->block1[i];
4944
4945 if (r->wvhdl[i] != NULL)
4946 {
4947 #ifdef HAVE_OMALLOC
4948 wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
4949 #else
4950 {
4951 int l=(r->block1[i]-r->block0[i]+1);
4952 if (r->order[i]==ringorder_a64) l*=2;
4953 else if (r->order[i]==ringorder_M) l=l*l;
4954 else if (r->order[i]==ringorder_am)
4955 {
4956 l+=r->wvhdl[i][r->block1[i]-r->block0[i]+1]+1;
4957 }
4958 wvhdl[j]=(int*)omalloc(l*sizeof(int));
4959 memcpy(wvhdl[j],r->wvhdl[i],l*sizeof(int));
4960 }
4961 #endif
4962 } // else wvhdl[j] = NULL;
4963 }
4964
4965 // new last block
4966 res->order [j] = ringorder_IS; // Suffix
4967 res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
4968 // wvhdl[j] = NULL;
4969 j++;
4970
4971 // res->order [j] = 0; // The End!
4972 res->wvhdl = wvhdl;
4973
4974 // j == the last zero block now!
4975 assume(j == (n+1));
4976 assume(res->order[0]==ringorder_IS);
4977 assume(res->order[j-1]==ringorder_IS);
4978 assume(res->order[j]==0);
4979
4980
4981 if (complete)
4982 {
4983 rComplete(res, 1);
4984
4985#ifdef HAVE_PLURAL
4986 if (rIsPluralRing(r))
4987 {
4988 if ( nc_rComplete(r, res, false) ) // no qideal!
4989 {
4990#ifndef SING_NDEBUG
4991 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4992#endif
4993 }
4994 }
4996#endif
4997
4998
4999#ifdef HAVE_PLURAL
5000 ring old_ring = r;
5001#endif
5002
5003 if (r->qideal!=NULL)
5004 {
5005 res->qideal= idrCopyR_NoSort(r->qideal, r, res);
5006
5007 assume(id_RankFreeModule(res->qideal, res) == 0);
5008
5009#ifdef HAVE_PLURAL
5010 if( rIsPluralRing(res) )
5011 if( nc_SetupQuotient(res, r, true) )
5012 {
5013// WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
5014 }
5015
5016#endif
5017 assume(id_RankFreeModule(res->qideal, res) == 0);
5018 }
5019
5020#ifdef HAVE_PLURAL
5021 assume((res->qideal==NULL) == (old_ring->qideal==NULL));
5025#endif
5026 }
5027
5028 return res;
5029}
int sgn(const Rational &a)
Definition GMPrat.cc:430
CanonicalForm res
Definition facAbsFact.cc:60
static bool rIsSCA(const ring r)
Definition nc.h:190
bool nc_SetupQuotient(ring rGR, const ring rG=NULL, bool bCopy=false)
static nc_type & ncRingType(nc_struct *p)
Definition nc.h:159
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition prCopy.cc:205
void rWrite(ring r, BOOLEAN details)
Definition ring.cc:226
void rDebugPrint(const ring r)
Definition ring.cc:4131
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s

◆ rAssure_SyzComp()

ring rAssure_SyzComp ( const ring  r,
BOOLEAN  complete = TRUE 
)

Definition at line 4444 of file ring.cc.

4445{
4446 if ( r->order[0] == ringorder_s ) return r;
4447
4448 if ( r->order[0] == ringorder_IS )
4449 {
4450#ifndef SING_NDEBUG
4451 WarnS("rAssure_SyzComp: input ring has an IS-ordering!");
4452#endif
4453// return r;
4454 }
4455 ring res=rCopy0(r, FALSE, FALSE);
4456 int i=rBlocks(r);
4457 int j;
4458
4459 res->order=(rRingOrder_t *)omAlloc((i+1)*sizeof(rRingOrder_t));
4460 res->block0=(int *)omAlloc0((i+1)*sizeof(int));
4461 res->block1=(int *)omAlloc0((i+1)*sizeof(int));
4462 int ** wvhdl =(int **)omAlloc0((i+1)*sizeof(int**));
4463 for(j=i;j>0;j--)
4464 {
4465 res->order[j]=r->order[j-1];
4466 res->block0[j]=r->block0[j-1];
4467 res->block1[j]=r->block1[j-1];
4468 if (r->wvhdl[j-1] != NULL)
4469 {
4470 #ifdef HAVE_OMALLOC
4471 wvhdl[j] = (int*) omMemDup(r->wvhdl[j-1]);
4472 #else
4473 {
4474 int l=r->block1[j-1]-r->block0[j-1]+1;
4475 if (r->order[j-1]==ringorder_a64) l*=2;
4476 else if (r->order[j-1]==ringorder_M) l=l*l;
4477 else if (r->order[j-1]==ringorder_am)
4478 {
4479 l+=r->wvhdl[j-1][r->block1[j-1]-r->block0[j-1]+1]+1;
4480 }
4481 wvhdl[j]=(int*)omalloc(l*sizeof(int));
4482 memcpy(wvhdl[j],r->wvhdl[j-1],l*sizeof(int));
4483 }
4484 #endif
4485 }
4486 }
4487 res->order[0]=ringorder_s;
4488
4489 res->wvhdl = wvhdl;
4490
4491 if (complete)
4492 {
4493 rComplete(res, 1);
4494#ifdef HAVE_PLURAL
4495 if (rIsPluralRing(r))
4496 {
4497 if ( nc_rComplete(r, res, false) ) // no qideal!
4498 {
4499#ifndef SING_NDEBUG
4500 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4501#endif
4502 }
4503 }
4505#endif
4506
4507#ifdef HAVE_PLURAL
4508 ring old_ring = r;
4509#endif
4510 if (r->qideal!=NULL)
4511 {
4512 res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4513 assume(id_RankFreeModule(res->qideal, res) == 0);
4514#ifdef HAVE_PLURAL
4515 if( rIsPluralRing(res) )
4516 {
4517 if( nc_SetupQuotient(res, r, true) )
4518 {
4519// WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4520 }
4521 assume(id_RankFreeModule(res->qideal, res) == 0);
4522 }
4523#endif
4524 }
4525
4526#ifdef HAVE_PLURAL
4527 assume((res->qideal==NULL) == (old_ring->qideal==NULL));
4531#endif
4532 }
4533 return res;
4534}
#define omAlloc(size)

◆ rAssure_SyzComp_CompLastBlock()

ring rAssure_SyzComp_CompLastBlock ( const ring  r)

makes sure that c/C ordering is last ordering and SyzIndex is first

? rChangeCurrRing(new_r);

Definition at line 4758 of file ring.cc.

4759{
4760 rTest(r);
4761
4762 ring new_r_1 = rAssure_CompLastBlock(r, FALSE); // due to this FALSE - no completion!
4763 ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
4764
4765 if (new_r == r)
4766 return r;
4767
4768 ring old_r = r;
4769 if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
4770
4772#ifdef HAVE_PLURAL
4773 if (rIsPluralRing(old_r))
4774 {
4775 if ( nc_rComplete(old_r, new_r, false) ) // no qideal!
4776 {
4777# ifndef SING_NDEBUG
4778 WarnS("error in nc_rComplete"); // cleanup? rDelete(res); return r; // just go on...?
4779# endif
4780 }
4781 }
4782#endif
4783
4784///? rChangeCurrRing(new_r);
4785 if (old_r->qideal != NULL)
4786 {
4787 new_r->qideal = idrCopyR(old_r->qideal, old_r, new_r);
4788 }
4789
4790#ifdef HAVE_PLURAL
4791 if( rIsPluralRing(old_r) )
4792 if( nc_SetupQuotient(new_r, old_r, true) )
4793 {
4794#ifndef SING_NDEBUG
4795 WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4796#endif
4797 }
4798#endif
4799
4800#ifdef HAVE_PLURAL
4801 assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
4805#endif
4806
4807 rTest(new_r);
4808 rTest(old_r);
4809 return new_r;
4810}
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition prCopy.cc:192
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition ring.cc:4444
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:450
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
Definition ring.cc:4703
#define rTest(r)
Definition ring.h:785

◆ rAssure_SyzOrder()

ring rAssure_SyzOrder ( const ring  r,
BOOLEAN  complete 
)

Definition at line 4439 of file ring.cc.

4440{
4441 if ( r->order[0] == ringorder_c ) return r;
4442 return rAssure_SyzComp(r,complete);
4443}

◆ rAssure_TDeg()

ring rAssure_TDeg ( const ring  r,
int pos 
)

Definition at line 4536 of file ring.cc.

4537{
4538 if (r->N==1) // special: dp(1)==lp(1)== no entry in typ
4539 {
4540 pos=r->VarL_LowIndex;
4541 return r;
4542 }
4543 if (r->typ!=NULL)
4544 {
4545 for(int i=r->OrdSize-1;i>=0;i--)
4546 {
4547 if ((r->typ[i].ord_typ==ro_dp)
4548 && (r->typ[i].data.dp.start==1)
4549 && (r->typ[i].data.dp.end==r->N))
4550 {
4551 pos=r->typ[i].data.dp.place;
4552 //printf("no change, pos=%d\n",pos);
4553 return r;
4554 }
4555 }
4556 }
4557
4558#ifdef HAVE_PLURAL
4559 nc_struct* save=r->GetNC();
4560 r->GetNC()=NULL;
4561#endif
4562 ring res=rCopy(r);
4563 if (res->qideal!=NULL)
4564 {
4565 id_Delete(&res->qideal,r);
4566 }
4567
4568 int j;
4569
4570 res->ExpL_Size=r->ExpL_Size+1; // one word more in each monom
4571 res->PolyBin=omGetSpecBin(POLYSIZE + (res->ExpL_Size)*sizeof(long));
4572 omFree((ADDRESS)res->ordsgn);
4573 res->ordsgn=(long *)omAlloc0(res->ExpL_Size*sizeof(long));
4574 for(j=0;j<r->CmpL_Size;j++)
4575 {
4576 res->ordsgn[j] = r->ordsgn[j];
4577 }
4578 res->OrdSize=r->OrdSize+1; // one block more for pSetm
4579 if (r->typ!=NULL)
4580 omFree((ADDRESS)res->typ);
4581 res->typ=(sro_ord*)omAlloc0(res->OrdSize*sizeof(sro_ord));
4582 if (r->typ!=NULL)
4583 memcpy(res->typ,r->typ,r->OrdSize*sizeof(sro_ord));
4584 // the additional block for pSetm: total degree at the last word
4585 // but not included in the compare part
4586 res->typ[res->OrdSize-1].ord_typ=ro_dp;
4587 res->typ[res->OrdSize-1].data.dp.start=1;
4588 res->typ[res->OrdSize-1].data.dp.end=res->N;
4589 res->typ[res->OrdSize-1].data.dp.place=res->ExpL_Size-1;
4590 pos=res->ExpL_Size-1;
4591 //res->pOrdIndex=pos; //NO: think of a(1,0),dp !
4592 extern void p_Setm_General(poly p, ring r);
4593 res->p_Setm=p_Setm_General;
4594 // ----------------------------
4595 omFree((ADDRESS)res->p_Procs);
4596 res->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
4597
4598 p_ProcsSet(res, res->p_Procs);
4599#ifdef HAVE_PLURAL
4600 r->GetNC()=save;
4601 if (rIsPluralRing(r))
4602 {
4603 if ( nc_rComplete(r, res, false) ) // no qideal!
4604 {
4605#ifndef SING_NDEBUG
4606 WarnS("error in nc_rComplete");
4607#endif
4608 // just go on..
4609 }
4610 }
4611#endif
4612 if (r->qideal!=NULL)
4613 {
4614 res->qideal=idrCopyR_NoSort(r->qideal,r, res);
4615#ifdef HAVE_PLURAL
4616 if (rIsPluralRing(res))
4617 {
4618// nc_SetupQuotient(res, currRing);
4619 nc_SetupQuotient(res, r); // ?
4620 }
4621 assume((res->qideal==NULL) == (r->qideal==NULL));
4622#endif
4623 }
4624
4625#ifdef HAVE_PLURAL
4627 assume(rIsSCA(res) == rIsSCA(r));
4629#endif
4630
4631 return res;
4632}
#define POLYSIZE
Definition monomials.h:233
#define omFree(addr)
#define omGetSpecBin(size)
Definition omBin.h:11
void p_ProcsSet(ring r, p_Procs_s *p_Procs)
void p_Setm_General(poly p, const ring r)
Definition p_polys.cc:158
ring rCopy(ring r)
Definition ring.cc:1731
struct p_Procs_s p_Procs_s
Definition ring.h:23
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition nc.h:68

◆ rAssure_Wp_C()

ring rAssure_Wp_C ( const ring  r,
intvec w 
)

Definition at line 4859 of file ring.cc.

4860{
4861 int r_blocks = rBlocks(r);
4862
4863 if ((r_blocks == 3) &&
4864 (r->order[0] == ringorder_Wp) &&
4865 (r->order[1] == ringorder_C) &&
4866 (r->order[2] == 0))
4867 {
4868 BOOLEAN ok=TRUE;
4869 for(int i=0;i<r->N;i++)
4870 {
4871 if ((*w)[i]!=r->wvhdl[0][i]) { ok=FALSE;break;}
4872 }
4873 if (ok) return r;
4874 }
4875 ring res = rCopy0(r, FALSE, FALSE);
4876 res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
4877 res->block0 = (int*)omAlloc0(3*sizeof(int));
4878 res->block1 = (int*)omAlloc0(3*sizeof(int));
4879 res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
4880 res->order[0] = ringorder_Wp;
4881 res->order[1] = ringorder_C;
4882 res->block0[1] = 1;
4883 res->block1[1] = r->N;
4884 res->wvhdl[0]=(int*)omAlloc(r->N*sizeof(int));
4885 for(int i=0;i<r->N;i++)
4886 {
4887 r->wvhdl[0][i]=(*w)[i];
4888 }
4889 rComplete(res, 1);
4890 if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4891#ifdef HAVE_PLURAL
4892 if (rIsPluralRing(r))
4893 {
4894 if ( nc_rComplete(r, res, false) ) // no qideal!
4895 {
4896#ifndef SING_NDEBUG
4897 WarnS("error in nc_rComplete");
4898#endif
4899 }
4900 }
4901#endif
4902// rChangeCurrRing(res);
4903 return res;
4904}
int BOOLEAN
Definition auxiliary.h:87
const CanonicalForm & w
Definition facAbsFact.cc:51

◆ rBlocks()

static int rBlocks ( const ring  r)
inlinestatic

Definition at line 568 of file ring.h.

569{
570 assume(r != NULL);
571 int i=0;
572 while (r->order[i]!=0) i++;
573 return i+1;
574}

◆ rCanShortOut()

static BOOLEAN rCanShortOut ( const ring  r)
inlinestatic

Definition at line 586 of file ring.h.

587{
588 assume(r != NULL); return (r->CanShortOut);
589}

◆ rChangeSComps()

void rChangeSComps ( int currComponents,
long currShiftedComponents,
int  length,
ring  r 
)

Definition at line 4414 of file ring.cc.

4415{
4416#ifdef PDEBUG
4418#else
4420#endif
4421}
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
Definition ring.cc:4376
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition ring.cc:4392
EXTERN_VAR long * currShiftedComponents
Definition syz.h:118

◆ rChar()

int rChar ( ring  r)

Definition at line 713 of file ring.cc.

713{ return r->cf->ch; }

◆ rCharStr()

char * rCharStr ( ring  r)

TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.

Definition at line 647 of file ring.cc.

647{ assume( r != NULL ); return nCoeffString(r->cf); }
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition coeffs.h:956

◆ rCheckIV()

BOOLEAN rCheckIV ( const intvec iv)

Definition at line 175 of file ring.cc.

176{
177 if ((iv->length()!=2)&&(iv->length()!=3))
178 {
179 WerrorS("weights only for orderings wp,ws,Wp,Ws,a,M");
180 return TRUE;
181 }
182 return FALSE;
183}
int length() const
Definition intvec.h:94
void WerrorS(const char *s)
Definition feFopen.cc:24

◆ rComplete()

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 VarOffset), unless they already exist with force == 1, new fields are always created (overwritten), even if they exist

Definition at line 3459 of file ring.cc.

3460{
3461 if (r->VarOffset!=NULL && force == 0) return FALSE;
3462 rSetOutParams(r);
3463 int n=rBlocks(r)-1;
3464 int i;
3465 int bits;
3466 r->bitmask=rGetExpSize(r->wanted_maxExp,bits,r->N);
3467 r->BitsPerExp = bits;
3468 r->ExpPerLong = BIT_SIZEOF_LONG / bits;
3469 r->divmask=rGetDivMask(bits);
3470
3471 // will be used for ordsgn:
3472 long *tmp_ordsgn=(long *)omAlloc0(3*(n+r->N)*sizeof(long));
3473 // will be used for VarOffset:
3474 int *v=(int *)omAlloc((r->N+1)*sizeof(int));
3475 for(i=r->N; i>=0 ; i--)
3476 {
3477 v[i]=-1;
3478 }
3479 sro_ord *tmp_typ=(sro_ord *)omAlloc0(3*(n+r->N)*sizeof(sro_ord));
3480 int typ_i=0;
3481 int prev_ordsgn=0;
3482
3483 // fill in v, tmp_typ, tmp_ordsgn, determine typ_i (== ordSize)
3484 int j=0;
3486
3487 BOOLEAN need_to_add_comp=FALSE; // Only for ringorder_s and ringorder_S!
3488
3489 for(i=0;i<n;i++)
3490 {
3491 tmp_typ[typ_i].order_index=i;
3492 switch (r->order[i])
3493 {
3494 case ringorder_a:
3495 case ringorder_aa:
3496 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3497 r->wvhdl[i]);
3498 typ_i++;
3499 break;
3500
3501 case ringorder_am:
3502 rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3503 r->wvhdl[i]);
3504 typ_i++;
3505 break;
3506
3507 case ringorder_a64:
3508 rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3509 tmp_typ[typ_i], (int64 *)(r->wvhdl[i]));
3510 typ_i++;
3511 break;
3512
3513 case ringorder_c:
3514 rO_Align(j, j_bits);
3516 r->ComponentOrder=1;
3517 break;
3518
3519 case ringorder_C:
3520 rO_Align(j, j_bits);
3522 r->ComponentOrder=-1;
3523 break;
3524
3525 case ringorder_M:
3526 {
3527 int k,l;
3528 k=r->block1[i]-r->block0[i]+1; // number of vars
3529 for(l=0;l<k;l++)
3530 {
3531 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3532 tmp_typ[typ_i],
3533 r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
3534 typ_i++;
3535 }
3536 break;
3537 }
3538
3539 case ringorder_lp:
3540 rO_LexVars(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3541 tmp_ordsgn,v,bits, -1);
3542 break;
3543
3544 case ringorder_ls:
3545 rO_LexVars_neg(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3546 tmp_ordsgn,v, bits, -1);
3547 break;
3548
3549 case ringorder_rs:
3550 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3551 tmp_ordsgn,v, bits, -1);
3552 break;
3553
3554 case ringorder_rp:
3555 rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3556 tmp_ordsgn,v, bits, -1);
3557 break;
3558
3559 case ringorder_dp:
3560 if (r->block0[i]==r->block1[i])
3561 {
3562 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3563 tmp_ordsgn,v, bits, -1);
3564 }
3565 else
3566 {
3567 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3568 tmp_typ[typ_i]);
3569 typ_i++;
3570 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
3571 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3572 }
3573 break;
3574
3575 case ringorder_Dp:
3576 if (r->block0[i]==r->block1[i])
3577 {
3578 rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3579 tmp_ordsgn,v, bits, -1);
3580 }
3581 else
3582 {
3583 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3584 tmp_typ[typ_i]);
3585 typ_i++;
3586 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3587 tmp_ordsgn,v, bits, r->block1[i]);
3588 }
3589 break;
3590
3591 case ringorder_ds:
3592 if (r->block0[i]==r->block1[i])
3593 {
3594 rO_LexVars_neg(j, j_bits,r->block0[i],r->block1[i],prev_ordsgn,
3595 tmp_ordsgn,v,bits, -1);
3596 }
3597 else
3598 {
3599 rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3600 tmp_typ[typ_i]);
3601 typ_i++;
3602 rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
3603 prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3604 }
3605 break;
3606
3607 case ringorder_Ds:
3608 if (r->block0[i]==r->block1[i])
3609 {
3610 rO_LexVars_neg(j, j_bits, r->block0[i],r->block0[i],prev_ordsgn,
3611 tmp_ordsgn,v, bits, -1);
3612 }
3613 else
3614 {
3615 rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3616 tmp_typ[typ_i]);
3617 typ_i++;
3618 rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3619 tmp_ordsgn,v, bits, r->block1[i]);
3620 }
3621 break;
3622
3623 case ringorder_wp:
3624 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3625 tmp_typ[typ_i], r->wvhdl[i]);
3626 typ_i++;
3627 { // check for weights <=0
3628 int jj;
3630 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3631 {
3632 if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
3633 }
3634 if (have_bad_weights)
3635 {
3636 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3637 tmp_typ[typ_i]);
3638 typ_i++;
3639 }
3640 }
3641 if (r->block1[i]!=r->block0[i])
3642 {
3643 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3644 tmp_ordsgn, v,bits, r->block0[i]);
3645 }
3646 break;
3647
3648 case ringorder_Wp:
3649 rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3650 tmp_typ[typ_i], r->wvhdl[i]);
3651 typ_i++;
3652 { // check for weights <=0
3653 int jj;
3655 for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3656 {
3657 if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
3658 }
3659 if (have_bad_weights)
3660 {
3661 rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3662 tmp_typ[typ_i]);
3663 typ_i++;
3664 }
3665 }
3666 if (r->block1[i]!=r->block0[i])
3667 {
3668 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3669 tmp_ordsgn,v, bits, r->block1[i]);
3670 }
3671 break;
3672
3673 case ringorder_ws:
3674 rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3675 tmp_typ[typ_i], r->wvhdl[i]);
3676 typ_i++;
3677 if (r->block1[i]!=r->block0[i])
3678 {
3679 rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3680 tmp_ordsgn, v,bits, r->block0[i]);
3681 }
3682 break;
3683
3684 case ringorder_Ws:
3685 rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3686 tmp_typ[typ_i], r->wvhdl[i]);
3687 typ_i++;
3688 if (r->block1[i]!=r->block0[i])
3689 {
3690 rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3691 tmp_ordsgn,v, bits, r->block1[i]);
3692 }
3693 break;
3694
3695 case ringorder_S:
3696 assume(typ_i == 1); // For LaScala3 only: on the 2nd place ([1])!
3697 // TODO: for K[x]: it is 0...?!
3700 r->ComponentOrder=-1;
3701 typ_i++;
3702 break;
3703
3704 case ringorder_s:
3705 assume(typ_i == 0 && j == 0);
3706 rO_Syz(j, j_bits, prev_ordsgn, r->block0[i], tmp_ordsgn, tmp_typ[typ_i]); // set syz-limit?
3708 r->ComponentOrder=-1;
3709 typ_i++;
3710 break;
3711
3712 case ringorder_IS:
3713 {
3714
3715 assume( r->block0[i] == r->block1[i] );
3716 const int s = r->block0[i];
3717 assume( -2 < s && s < 2);
3718
3719 if(s == 0) // Prefix IS
3720 rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]); // What about prev_ordsgn?
3721 else // s = +1 or -1 // Note: typ_i might be incremented here inside!
3722 {
3723 rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s); // Suffix.
3725 }
3726
3727 break;
3728 }
3729 case ringorder_unspec:
3730 case ringorder_no:
3731 default:
3732 dReportError("undef. ringorder used\n");
3733 break;
3734 }
3735 }
3736 rCheckOrdSgn(r,n-1);
3737
3738 int j0=j; // save j
3739 int j_bits0=j_bits; // save jbits
3740 rO_Align(j,j_bits);
3741 r->CmpL_Size = j;
3742
3743 j_bits=j_bits0; j=j0;
3744
3745 // fill in some empty slots with variables not already covered
3746 // v0 is special, is therefore normally already covered
3747 // now we do have rings without comp...
3748 if((need_to_add_comp) && (v[0]== -1))
3749 {
3750 if (prev_ordsgn==1)
3751 {
3752 rO_Align(j, j_bits);
3754 }
3755 else
3756 {
3757 rO_Align(j, j_bits);
3759 }
3760 }
3761 // the variables
3762 for(i=1 ; i<=r->N ; i++)
3763 {
3764 if(v[i]==(-1))
3765 {
3766 if (prev_ordsgn==1)
3767 {
3769 }
3770 else
3771 {
3773 }
3774 }
3775 }
3776
3777 rO_Align(j,j_bits);
3778 // ----------------------------
3779 // finished with constructing the monomial, computing sizes:
3780
3781 r->ExpL_Size=j;
3782 r->PolyBin = omGetSpecBin(POLYSIZE + (r->ExpL_Size)*sizeof(long));
3783 assume(r->PolyBin != NULL);
3784
3785 // ----------------------------
3786 // indices and ordsgn vector for comparison
3787 //
3788 // r->pCompHighIndex already set
3789 r->ordsgn=(long *)omAlloc0(r->ExpL_Size*sizeof(long));
3790
3791 for(j=0;j<r->CmpL_Size;j++)
3792 {
3793 r->ordsgn[j] = tmp_ordsgn[j];
3794 }
3795
3796 omFreeSize((ADDRESS)tmp_ordsgn,(3*(n+r->N)*sizeof(long)));
3797
3798 // ----------------------------
3799 // description of orderings for setm:
3800 //
3801 r->OrdSize=typ_i;
3802 if (typ_i==0) r->typ=NULL;
3803 else
3804 {
3805 r->typ=(sro_ord*)omAlloc(typ_i*sizeof(sro_ord));
3806 memcpy(r->typ,tmp_typ,typ_i*sizeof(sro_ord));
3807 }
3808 omFreeSize((ADDRESS)tmp_typ,(3*(n+r->N)*sizeof(sro_ord)));
3809
3810 // ----------------------------
3811 // indices for (first copy of ) variable entries in exp.e vector (VarOffset):
3812 r->VarOffset=v;
3813
3814 // ----------------------------
3815 // other indicies
3816 r->pCompIndex=(r->VarOffset[0] & 0xffff); //r->VarOffset[0];
3817 i=0; // position
3818 j=0; // index in r->typ
3819 if (i==r->pCompIndex) i++; // IS???
3820 while ((j < r->OrdSize)
3821 && ((r->typ[j].ord_typ==ro_syzcomp) ||
3822 (r->typ[j].ord_typ==ro_syz) || (r->typ[j].ord_typ==ro_isTemp) || (r->typ[j].ord_typ==ro_is) ||
3823 (r->order[r->typ[j].order_index] == ringorder_aa)))
3824 {
3825 i++; j++;
3826 }
3827
3828 if (i==r->pCompIndex) i++;
3829 r->pOrdIndex=i;
3830
3831 // ----------------------------
3832 rSetDegStuff(r); // OrdSgn etc already set
3833 rSetOption(r);
3834 // ----------------------------
3835 // r->p_Setm
3836 r->p_Setm = p_GetSetmProc(r);
3837
3838 // ----------------------------
3839 // set VarL_*
3840 rSetVarL(r);
3841
3842 // ----------------------------
3843 // right-adjust VarOffset
3845
3846 // ----------------------------
3847 // set NegWeightL*
3848 rSetNegWeight(r);
3849
3850 // ----------------------------
3851 // p_Procs: call AFTER NegWeightL
3852 r->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
3853 p_ProcsSet(r, r->p_Procs);
3854
3855 // use totaldegree on crazy oderings:
3856 if ((r->pFDeg==p_WTotaldegree) && rOrd_is_MixedDegree_Ordering(r))
3857 r->pFDeg = p_Totaldegree;
3858 return FALSE;
3859}
long int64
Definition auxiliary.h:68
#define BIT_SIZEOF_LONG
Definition auxiliary.h:80
int k
Definition cfEzgcd.cc:99
const CanonicalForm int s
Definition facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
int dReportError(const char *fmt,...)
Definition dError.cc:44
#define omFreeSize(addr, size)
long p_WTotaldegree(poly p, const ring r)
Definition p_polys.cc:613
p_SetmProc p_GetSetmProc(const ring r)
Definition p_polys.cc:560
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1507
static void rSetNegWeight(ring r)
Definition ring.cc:3356
static void rO_ISSuffix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
Definition ring.cc:2488
static void rSetOption(ring r)
Definition ring.cc:3393
#define BITS_PER_LONG
Definition ring.cc:40
static void rO_WDegree64(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
Definition ring.cc:2298
static void rSetVarL(ring r)
set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
Definition ring.cc:4036
static void rO_LexVars(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
Definition ring.cc:2348
BOOLEAN rOrd_is_MixedDegree_Ordering(ring r)
Definition ring.cc:3437
static void rSetOutParams(ring r)
Definition ring.cc:3089
static void rSetDegStuff(ring r)
Definition ring.cc:3186
static void rO_WDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition ring.cc:2322
static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
Definition ring.cc:2424
static void rO_TDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition ring.cc:2208
static void rO_WMDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition ring.cc:2276
static void rO_Syz(int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
Definition ring.cc:2439
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
Definition ring.cc:2579
static void rCheckOrdSgn(ring r, int i)
Definition ring.cc:3861
static unsigned long rGetDivMask(int bits)
get r->divmask depending on bits per exponent
Definition ring.cc:4117
static void rRightAdjustVarOffset(ring r)
right-adjust r->VarOffset
Definition ring.cc:4091
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
Definition ring.cc:2465
static void rO_Align(int &place, int &bitplace)
Definition ring.cc:2197
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition ring.cc:2222
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition ring.cc:2236
static void rO_LexVars_neg(int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
Definition ring.cc:2385

◆ rCopy()

ring rCopy ( ring  r)

Definition at line 1731 of file ring.cc.

1732{
1733 if (r == NULL) return NULL;
1735 rComplete(res, 1); // res is purely commutative so far
1736 if (r->qideal!=NULL) res->qideal=idrCopyR_NoSort(r->qideal, r, res);
1737
1738#ifdef HAVE_PLURAL
1739 if (rIsPluralRing(r))
1740 if( nc_rCopy(res, r, true) ) {}
1741#endif
1742
1743 return res;
1744}
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)

◆ rCopy0()

ring rCopy0 ( const ring  r,
BOOLEAN  copy_qideal = TRUE,
BOOLEAN  copy_ordering = TRUE 
)

Definition at line 1421 of file ring.cc.

1422{
1423 if (r == NULL) return NULL;
1424 int i,j;
1426 //memset: res->idroot=NULL; /* local objects */
1427 //ideal minideal;
1428 res->options=r->options; /* ring dependent options */
1429
1430 //memset: res->ordsgn=NULL;
1431 //memset: res->typ=NULL;
1432 //memset: res->VarOffset=NULL;
1433 //memset: res->firstwv=NULL;
1434
1435 //struct omBin PolyBin; /* Bin from where monoms are allocated */
1436 //memset: res->PolyBin=NULL; // rComplete
1437 res->cf=nCopyCoeff(r->cf); /* coeffs */
1438
1439 //memset: res->ref=0; /* reference counter to the ring */
1440
1441 res->N=rVar(r); /* number of vars */
1442
1443 res->firstBlockEnds=r->firstBlockEnds;
1444#ifdef HAVE_PLURAL
1445 res->real_var_start=r->real_var_start;
1446 res->real_var_end=r->real_var_end;
1447#endif
1448
1449#ifdef HAVE_SHIFTBBA
1450 res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
1451 res->LPncGenCount=r->LPncGenCount;
1452#endif
1453
1454 res->VectorOut=r->VectorOut;
1455 res->ShortOut=r->ShortOut;
1456 res->CanShortOut=r->CanShortOut;
1457
1458 //memset: res->ExpL_Size=0;
1459 //memset: res->CmpL_Size=0;
1460 //memset: res->VarL_Size=0;
1461 //memset: res->pCompIndex=0;
1462 //memset: res->pOrdIndex=0;
1463 //memset: res->OrdSize=0;
1464 //memset: res->VarL_LowIndex=0;
1465 //memset: res->NegWeightL_Size=0;
1466 //memset: res->NegWeightL_Offset=NULL;
1467 //memset: res->VarL_Offset=NULL;
1468
1469 // the following are set by rComplete unless predefined
1470 // therefore, we copy these values: maybe they are non-standard
1471 /* mask for getting single exponents */
1472 res->bitmask=r->bitmask;
1473 res->divmask=r->divmask;
1474 res->BitsPerExp = r->BitsPerExp;
1475 res->ExpPerLong = r->ExpPerLong;
1476
1477 //memset: res->p_Procs=NULL;
1478 //memset: res->pFDeg=NULL;
1479 //memset: res->pLDeg=NULL;
1480 //memset: res->pFDegOrig=NULL;
1481 //memset: res->pLDegOrig=NULL;
1482 //memset: res->p_Setm=NULL;
1483 //memset: res->cf=NULL;
1484
1485/*
1486 if (r->extRing!=NULL)
1487 r->extRing->ref++;
1488
1489 res->extRing=r->extRing;
1490 //memset: res->qideal=NULL;
1491*/
1492
1493
1494 if (copy_ordering == TRUE)
1495 {
1496 res->LexOrder=r->LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
1497 res->MixedOrder=r->MixedOrder; // TRUE for mixed (global/local) ordering, FALSE otherwise,
1498 i=rBlocks(r);
1499 res->wvhdl = (int **)omAlloc(i * sizeof(int *));
1500 res->order = (rRingOrder_t *) omAlloc(i * sizeof(rRingOrder_t));
1501 res->block0 = (int *) omAlloc(i * sizeof(int));
1502 res->block1 = (int *) omAlloc(i * sizeof(int));
1503 for (j=0; j<i; j++)
1504 {
1505 if (r->wvhdl[j]!=NULL)
1506 {
1507 #ifdef HAVE_OMALLOC
1508 res->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
1509 #else
1510 {
1511 int l=r->block1[j]-r->block0[j]+1;
1512 if (r->order[j]==ringorder_a64) l*=2;
1513 else if (r->order[j]==ringorder_M) l=l*l;
1514 else if (r->order[j]==ringorder_am)
1515 {
1516 l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
1517 }
1518 res->wvhdl[j]=(int*)omalloc(l*sizeof(int));
1519 memcpy(res->wvhdl[j],r->wvhdl[j],l*sizeof(int));
1520 }
1521 #endif
1522 }
1523 else
1524 res->wvhdl[j]=NULL;
1525 }
1526 memcpy(res->order,r->order,i * sizeof(rRingOrder_t));
1527 memcpy(res->block0,r->block0,i * sizeof(int));
1528 memcpy(res->block1,r->block1,i * sizeof(int));
1529 }
1530 //memset: else
1531 //memset: {
1532 //memset: res->wvhdl = NULL;
1533 //memset: res->order = NULL;
1534 //memset: res->block0 = NULL;
1535 //memset: res->block1 = NULL;
1536 //memset: }
1537
1538 res->names = (char **)omAlloc0(rVar(r) * sizeof(char *));
1539 for (i=0; i<rVar(res); i++)
1540 {
1541 res->names[i] = omStrDup(r->names[i]);
1542 }
1543 if (r->qideal!=NULL)
1544 {
1545 if (copy_qideal)
1546 {
1548 rComplete(res);
1549 res->qideal= idrCopyR_NoSort(r->qideal, r, res);
1551 }
1552 //memset: else res->qideal = NULL;
1553 }
1554 //memset: else res->qideal = NULL;
1555 //memset: res->GetNC() = NULL; // copy is purely commutative!!!
1556 return res;
1557}
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition coeffs.h:430
#define omStrDup(s)
#define omAlloc0Bin(bin)
VAR omBin sip_sring_bin
Definition ring.cc:43
void rUnComplete(ring r)
Definition ring.cc:3974
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:592

◆ rCopy0AndAddA()

ring rCopy0AndAddA ( ring  r,
int64vec wv64,
BOOLEAN  copy_qideal = TRUE,
BOOLEAN  copy_ordering = TRUE 
)

Definition at line 1564 of file ring.cc.

1565{
1566 if (r == NULL) return NULL;
1567 int i,j;
1569 //memcpy(res,r,sizeof(ip_sring));
1570 //memset: res->idroot=NULL; /* local objects */
1571 //ideal minideal;
1572 res->options=r->options; /* ring dependent options */
1573
1574 //memset: res->ordsgn=NULL;
1575 //memset: res->typ=NULL;
1576 //memset: res->VarOffset=NULL;
1577 //memset: res->firstwv=NULL;
1578
1579 //struct omBin PolyBin; /* Bin from where monoms are allocated */
1580 //memset: res->PolyBin=NULL; // rComplete
1581 res->cf=nCopyCoeff(r->cf); /* coeffs */
1582
1583 //memset: res->ref=0; /* reference counter to the ring */
1584
1585 res->N=rVar(r); /* number of vars */
1586
1587 res->firstBlockEnds=r->firstBlockEnds;
1588#ifdef HAVE_PLURAL
1589 res->real_var_start=r->real_var_start;
1590 res->real_var_end=r->real_var_end;
1591#endif
1592
1593#ifdef HAVE_SHIFTBBA
1594 res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
1595 res->LPncGenCount=r->LPncGenCount;
1596#endif
1597
1598 res->VectorOut=r->VectorOut;
1599 res->ShortOut=r->ShortOut;
1600 res->CanShortOut=r->CanShortOut;
1601 res->LexOrder=r->LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
1602 res->MixedOrder=r->MixedOrder; // TRUE for mixed (global/local) ordering, FALSE otherwise,
1603
1604 //memset: res->ExpL_Size=0;
1605 //memset: res->CmpL_Size=0;
1606 //memset: res->VarL_Size=0;
1607 //memset: res->pCompIndex=0;
1608 //memset: res->pOrdIndex=0;
1609 //memset: res->OrdSize=0;
1610 //memset: res->VarL_LowIndex=0;
1611 //memset: res->NegWeightL_Size=0;
1612 //memset: res->NegWeightL_Offset=NULL;
1613 //memset: res->VarL_Offset=NULL;
1614
1615 // the following are set by rComplete unless predefined
1616 // therefore, we copy these values: maybe they are non-standard
1617 /* mask for getting single exponents */
1618 res->bitmask=r->bitmask;
1619 res->divmask=r->divmask;
1620 res->BitsPerExp = r->BitsPerExp;
1621 res->ExpPerLong = r->ExpPerLong;
1622
1623 //memset: res->p_Procs=NULL;
1624 //memset: res->pFDeg=NULL;
1625 //memset: res->pLDeg=NULL;
1626 //memset: res->pFDegOrig=NULL;
1627 //memset: res->pLDegOrig=NULL;
1628 //memset: res->p_Setm=NULL;
1629 //memset: res->cf=NULL;
1630
1631/*
1632 if (r->extRing!=NULL)
1633 r->extRing->ref++;
1634
1635 res->extRing=r->extRing;
1636 //memset: res->qideal=NULL;
1637*/
1638
1639
1640 if (copy_ordering == TRUE)
1641 {
1642 i=rBlocks(r)+1; // DIFF to rCopy0
1643 res->wvhdl = (int **)omAlloc(i * sizeof(int *));
1644 res->order = (rRingOrder_t *) omAlloc(i * sizeof(rRingOrder_t));
1645 res->block0 = (int *) omAlloc(i * sizeof(int));
1646 res->block1 = (int *) omAlloc(i * sizeof(int));
1647 for (j=0; j<i-1; j++)
1648 {
1649 if (r->wvhdl[j]!=NULL)
1650 {
1651 #ifdef HAVE_OMALLOC
1652 res->wvhdl[j+1] = (int*) omMemDup(r->wvhdl[j]); //DIFF
1653 #else
1654 {
1655 int l=r->block1[j]-r->block0[j]+1;
1656 if (r->order[j]==ringorder_a64) l*=2;
1657 else if (r->order[j]==ringorder_M) l=l*l;
1658 else if (r->order[j]==ringorder_am)
1659 {
1660 l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
1661 }
1662 res->wvhdl[j+1]=(int*)omalloc(l*sizeof(int));
1663 memcpy(res->wvhdl[j+1],r->wvhdl[j],l*sizeof(int));
1664 }
1665 #endif
1666 }
1667 else
1668 res->wvhdl[j+1]=NULL; //DIFF
1669 }
1670 memcpy(&(res->order[1]),r->order,(i-1) * sizeof(rRingOrder_t)); //DIFF
1671 memcpy(&(res->block0[1]),r->block0,(i-1) * sizeof(int)); //DIFF
1672 memcpy(&(res->block1[1]),r->block1,(i-1) * sizeof(int)); //DIFF
1673 }
1674 //memset: else
1675 //memset: {
1676 //memset: res->wvhdl = NULL;
1677 //memset: res->order = NULL;
1678 //memset: res->block0 = NULL;
1679 //memset: res->block1 = NULL;
1680 //memset: }
1681
1682 //the added A
1683 res->order[0]=ringorder_a64;
1684 int length=wv64->rows();
1685 int64 *A=(int64 *)omAlloc(length*sizeof(int64));
1686 for(j=length-1;j>=0;j--)
1687 {
1688 A[j]=(*wv64)[j];
1689 }
1690 res->wvhdl[0]=(int *)A;
1691 res->block0[0]=1;
1692 res->block1[0]=length;
1693 //
1694
1695 res->names = (char **)omAlloc0(rVar(r) * sizeof(char *));
1696 for (i=0; i<rVar(res); i++)
1697 {
1698 res->names[i] = omStrDup(r->names[i]);
1699 }
1700 if (r->qideal!=NULL)
1701 {
1702 if (copy_qideal)
1703 {
1704 #ifndef SING_NDEBUG
1705 if (!copy_ordering)
1706 WerrorS("internal error: rCopy0(Q,TRUE,FALSE)");
1707 else
1708 #endif
1709 {
1710 #ifndef SING_NDEBUG
1711 WarnS("internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1712 #endif
1713 rComplete(res);
1714 res->qideal= idrCopyR_NoSort(r->qideal, r, res);
1716 }
1717 }
1718 //memset: else res->qideal = NULL;
1719 }
1720 //memset: else res->qideal = NULL;
1721 //memset: res->GetNC() = NULL; // copy is purely commutative!!!
1722 return res;
1723}
#define A
Definition sirandom.c:24

◆ rDBTest()

BOOLEAN rDBTest ( ring  r,
const char fn,
const int  l 
)
extern

Definition at line 2047 of file ring.cc.

2048{
2049 int i,j;
2050
2051 if (r == NULL)
2052 {
2053 dReportError("Null ring in %s:%d", fn, l);
2054 return FALSE;
2055 }
2056
2057
2058 if (r->N == 0) return TRUE;
2059
2060 if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2061 {
2062 dReportError("missing OrdSgn in %s:%d", fn, l);
2063 return FALSE;
2064 }
2065
2066// omCheckAddrSize(r,sizeof(ip_sring));
2067#if OM_CHECK > 0
2068 i=rBlocks(r);
2069 omCheckAddrSize(r->order,i*sizeof(int));
2070 omCheckAddrSize(r->block0,i*sizeof(int));
2071 omCheckAddrSize(r->block1,i*sizeof(int));
2072 for(int j=0;j<=i;j++)
2073 {
2074 if((r->order[j]<0)||(r->order[j]>ringorder_unspec))
2075 dError("wrong order in r->order");
2076 }
2077 if (r->wvhdl!=NULL)
2078 {
2079 omCheckAddrSize(r->wvhdl,i*sizeof(int *));
2080 for (j=0;j<i; j++)
2081 {
2082 if (r->wvhdl[j] != NULL) omCheckAddr(r->wvhdl[j]);
2083 }
2084 }
2085#endif
2086 if (r->VarOffset == NULL)
2087 {
2088 dReportError("Null ring VarOffset -- no rComplete (?) in n %s:%d", fn, l);
2089 return FALSE;
2090 }
2091 omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(int));
2092
2093 if ((r->OrdSize==0)!=(r->typ==NULL))
2094 {
2095 dReportError("mismatch OrdSize and typ-pointer in %s:%d");
2096 return FALSE;
2097 }
2098 omcheckAddrSize(r->typ,r->OrdSize*sizeof(*(r->typ)));
2099 omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(*(r->VarOffset)));
2100 // test assumptions:
2101 for(i=0;i<=r->N;i++) // for all variables (i = 0..N)
2102 {
2103 if(r->typ!=NULL)
2104 {
2105 for(j=0;j<r->OrdSize;j++) // for all ordering blocks (j =0..OrdSize-1)
2106 {
2107 if(r->typ[j].ord_typ == ro_isTemp)
2108 {
2109 const int p = r->typ[j].data.isTemp.suffixpos;
2110
2111 if(p <= j)
2112 dReportError("ordrec prefix %d is unmatched",j);
2113
2114 assume( p < r->OrdSize );
2115
2116 if(r->typ[p].ord_typ != ro_is)
2117 dReportError("ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
2118
2119 // Skip all intermediate blocks for undone variables:
2120 if(r->typ[j].data.isTemp.pVarOffset[i] != -1) // Check i^th variable
2121 {
2122 j = p - 1; // SKIP ALL INTERNAL BLOCKS...???
2123 continue; // To make for check OrdSize bound...
2124 }
2125 }
2126 else if (r->typ[j].ord_typ == ro_is)
2127 {
2128 // Skip all intermediate blocks for undone variables:
2129 if(r->typ[j].data.is.pVarOffset[i] != -1)
2130 {
2131 // TODO???
2132 }
2133
2134 }
2135 else
2136 {
2137 if (r->typ[j].ord_typ==ro_cp)
2138 {
2139 if(((short)r->VarOffset[i]) == r->typ[j].data.cp.place)
2140 dReportError("ordrec %d conflicts with var %d",j,i);
2141 }
2142 else
2143 if ((r->typ[j].ord_typ!=ro_syzcomp)
2144 && (r->VarOffset[i] == r->typ[j].data.dp.place))
2145 dReportError("ordrec %d conflicts with var %d",j,i);
2146 }
2147 }
2148 }
2149 int tmp;
2150 tmp=r->VarOffset[i] & 0xffffff;
2151 #if SIZEOF_LONG == 8
2152 if ((r->VarOffset[i] >> 24) >63)
2153 #else
2154 if ((r->VarOffset[i] >> 24) >31)
2155 #endif
2156 dReportError("bit_start out of range:%d",r->VarOffset[i] >> 24);
2157 if (i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2158 {
2159 dReportError("varoffset out of range for var %d: %d",i,tmp);
2160 }
2161 }
2162 if(r->typ!=NULL)
2163 {
2164 for(j=0;j<r->OrdSize;j++)
2165 {
2166 if ((r->typ[j].ord_typ==ro_dp)
2167 || (r->typ[j].ord_typ==ro_wp)
2168 || (r->typ[j].ord_typ==ro_wp_neg))
2169 {
2170 if (r->typ[j].data.dp.start > r->typ[j].data.dp.end)
2171 dReportError("in ordrec %d: start(%d) > end(%d)",j,
2172 r->typ[j].data.dp.start, r->typ[j].data.dp.end);
2173 if ((r->typ[j].data.dp.start < 1)
2174 || (r->typ[j].data.dp.end > r->N))
2175 dReportError("in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",j,
2176 r->typ[j].data.dp.start, r->typ[j].data.dp.end,r->N);
2177 }
2178 }
2179 }
2180
2181 assume(r != NULL);
2182 assume(r->cf != NULL);
2183
2184 if (nCoeff_is_algExt(r->cf))
2185 {
2186 assume(r->cf->extRing != NULL);
2187 assume(r->cf->extRing->qideal != NULL);
2188 omCheckAddr(r->cf->extRing->qideal->m[0]);
2189 }
2190
2191 //assume(r->cf!=NULL);
2192
2193 return TRUE;
2194}
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition coeffs.h:907
#define omCheckAddr(addr)
#define omCheckAddrSize(addr, size)
#define omcheckAddrSize(addr, size)

◆ rDebugPrint()

void rDebugPrint ( const ring  r)

Definition at line 4131 of file ring.cc.

4132{
4133 if (r==NULL)
4134 {
4135 PrintS("NULL ?\n");
4136 return;
4137 }
4138 // corresponds to ro_typ from ring.h:
4139 const char *TYP[]={"ro_dp","ro_wp","ro_am","ro_wp64","ro_wp_neg","ro_cp",
4140 "ro_syzcomp", "ro_syz", "ro_isTemp", "ro_is", "ro_none"};
4141 int i,j;
4142
4143 Print("ExpL_Size:%d ",r->ExpL_Size);
4144 Print("CmpL_Size:%d ",r->CmpL_Size);
4145 Print("VarL_Size:%d\n",r->VarL_Size);
4146 Print("bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4147 Print("divmask=%lx\n", r->divmask);
4148 Print("BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4149
4150 Print("VarL_LowIndex: %d\n", r->VarL_LowIndex);
4151 PrintS("VarL_Offset:\n");
4152 if (r->VarL_Offset==NULL) PrintS(" NULL");
4153 else
4154 for(j = 0; j < r->VarL_Size; j++)
4155 Print(" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
4156 PrintLn();
4157
4158
4159 PrintS("VarOffset:\n");
4160 if (r->VarOffset==NULL) PrintS(" NULL\n");
4161 else
4162 for(j=0;j<=r->N;j++)
4163 Print(" v%d at e-pos %d, bit %d\n",
4164 j,r->VarOffset[j] & 0xffffff, r->VarOffset[j] >>24);
4165 PrintS("ordsgn:\n");
4166 for(j=0;j<r->CmpL_Size;j++)
4167 Print(" ordsgn %ld at pos %d\n",r->ordsgn[j],j);
4168 Print("OrdSgn:%d\n",r->OrdSgn);
4169 PrintS("ordrec:\n");
4170 for(j=0;j<r->OrdSize;j++)
4171 {
4172 Print(" typ %s", TYP[r->typ[j].ord_typ]);
4173 if (r->typ[j].ord_typ==ro_syz)
4174 {
4175 const short place = r->typ[j].data.syz.place;
4176 const int limit = r->typ[j].data.syz.limit;
4177 const int curr_index = r->typ[j].data.syz.curr_index;
4178 const int* syz_index = r->typ[j].data.syz.syz_index;
4179
4180 Print(" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4181
4182 if( syz_index == NULL )
4183 PrintS("(NULL)");
4184 else
4185 {
4186 PrintS("{");
4187 for( i=0; i <= limit; i++ )
4188 Print("%d ", syz_index[i]);
4189 PrintS("}");
4190 }
4191
4192 }
4193 else if (r->typ[j].ord_typ==ro_isTemp)
4194 {
4195 Print(" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
4196
4197 }
4198 else if (r->typ[j].ord_typ==ro_is)
4199 {
4200 Print(" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
4201
4202// for( int k = 0; k <= r->N; k++) if (r->typ[j].data.is.pVarOffset[k] != -1) Print("[%2d]: %04x; ", k, r->typ[j].data.is.pVarOffset[k]);
4203
4204 Print(" limit %d",r->typ[j].data.is.limit);
4205#ifndef SING_NDEBUG
4206 //PrintS(" F: ");idShow(r->typ[j].data.is.F, r, r, 1);
4207#endif
4208
4209 PrintLn();
4210 }
4211 else if (r->typ[j].ord_typ==ro_am)
4212 {
4213 Print(" place %d",r->typ[j].data.am.place);
4214 Print(" start %d",r->typ[j].data.am.start);
4215 Print(" end %d",r->typ[j].data.am.end);
4216 Print(" len_gen %d",r->typ[j].data.am.len_gen);
4217 PrintS(" w:");
4218 int l=0;
4219 for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
4220 Print(" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
4221 l=r->typ[j].data.am.end+1;
4222 int ll=r->typ[j].data.am.weights[l-r->typ[j].data.am.start];
4223 PrintS(" m:");
4224 for(int lll=l+1;lll<l+ll+1;lll++)
4225 Print(" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
4226 }
4227 else
4228 {
4229 Print(" place %d",r->typ[j].data.dp.place);
4230
4231 if (r->typ[j].ord_typ!=ro_syzcomp && r->typ[j].ord_typ!=ro_syz)
4232 {
4233 Print(" start %d",r->typ[j].data.dp.start);
4234 Print(" end %d",r->typ[j].data.dp.end);
4235 if ((r->typ[j].ord_typ==ro_wp)
4236 || (r->typ[j].ord_typ==ro_wp_neg))
4237 {
4238 PrintS(" w:");
4239 for(int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;l++)
4240 Print(" %d",r->typ[j].data.wp.weights[l-r->typ[j].data.wp.start]);
4241 }
4242 else if (r->typ[j].ord_typ==ro_wp64)
4243 {
4244 PrintS(" w64:");
4245 int l;
4246 for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
4247 Print(" %ld",(long)(r->typ[j].data.wp64.weights64+l-r->typ[j].data.wp64.start));
4248 }
4249 }
4250 }
4251 PrintLn();
4252 }
4253 Print("pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4254 Print("OrdSize:%d\n",r->OrdSize);
4255 PrintS("--------------------\n");
4256 for(j=0;j<r->ExpL_Size;j++)
4257 {
4258 Print("L[%d]: ",j);
4259 if (j< r->CmpL_Size)
4260 Print("ordsgn %ld ", r->ordsgn[j]);
4261 else
4262 PrintS("no comp ");
4263 i=1;
4264 for(;i<=r->N;i++)
4265 {
4266 if( (r->VarOffset[i] & 0xffffff) == j )
4267 { Print("v%d at e[%d], bit %d; ", i,r->VarOffset[i] & 0xffffff,
4268 r->VarOffset[i] >>24 ); }
4269 }
4270 if( r->pCompIndex==j ) PrintS("v0; ");
4271 for(i=0;i<r->OrdSize;i++)
4272 {
4273 if (r->typ[i].data.dp.place == j)
4274 {
4275 Print("ordrec:%s (start:%d, end:%d) ",TYP[r->typ[i].ord_typ],
4276 r->typ[i].data.dp.start, r->typ[i].data.dp.end);
4277 }
4278 }
4279
4280 if (j==r->pOrdIndex)
4281 PrintS("pOrdIndex\n");
4282 else
4283 PrintLn();
4284 }
4285 Print("LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4286
4287 Print("NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4288 if (r->NegWeightL_Offset==NULL) PrintS(" NULL");
4289 else
4290 for(j = 0; j < r->NegWeightL_Size; j++)
4291 Print(" [%d]: %d ", j, r->NegWeightL_Offset[j]);
4292 PrintLn();
4293
4294 // p_Procs stuff
4296 const char* field;
4297 const char* length;
4298 const char* ord;
4299 p_Debug_GetProcNames(r, &proc_names); // changes p_Procs!!!
4301
4302 Print("p_Spec : %s, %s, %s\n", field, length, ord);
4303 PrintS("p_Procs :\n");
4304 for (i=0; i<(int) (sizeof(p_Procs_s)/sizeof(void*)); i++)
4305 {
4306 Print(" %s,\n", ((char**) &proc_names)[i]);
4307 }
4308
4309 {
4310 PrintLn();
4311 PrintS("pFDeg : ");
4312#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4316 pFDeg_CASE(p_Deg); else
4317#undef pFDeg_CASE
4318 Print("(%p)", r->pFDeg); // default case
4319
4320 PrintLn();
4321 Print("pLDeg : (%p)", r->pLDeg);
4322 PrintLn();
4323 }
4324 PrintS("pSetm:");
4325 void p_Setm_Dummy(poly p, const ring r);
4326 void p_Setm_TotalDegree(poly p, const ring r);
4327 void p_Setm_WFirstTotalDegree(poly p, const ring r);
4328 void p_Setm_General(poly p, const ring r);
4329 if (r->p_Setm==p_Setm_General) PrintS("p_Setm_General\n");
4330 else if (r->p_Setm==p_Setm_Dummy) PrintS("p_Setm_Dummy\n");
4331 else if (r->p_Setm==p_Setm_TotalDegree) PrintS("p_Setm_Totaldegree\n");
4332 else if (r->p_Setm==p_Setm_WFirstTotalDegree) PrintS("p_Setm_WFirstTotalDegree\n");
4333 else Print("%p\n",r->p_Setm);
4334}
void p_Debug_GetProcNames(const ring r, p_Procs_s *p_Procs)
void p_Debug_GetSpecNames(const ring r, const char *&field, const char *&length, const char *&ord)
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:554
long p_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:596
void p_Setm_Dummy(poly p, const ring r)
Definition p_polys.cc:541
void p_Setm_TotalDegree(poly p, const ring r)
Definition p_polys.cc:547
long p_Deg(poly a, const ring r)
Definition p_polys.cc:587
#define pFDeg_CASE(A)

◆ rDecRefCnt()

static void rDecRefCnt ( ring  r)
inlinestatic

Definition at line 841 of file ring.h.

841{ r->ref--; }

◆ rDefault() [1/4]

ring rDefault ( const coeffs  cf,
int  N,
char **  n,
const rRingOrder_t  o = ringorder_lp 
)

Definition at line 138 of file ring.cc.

139{
140 assume( cf != NULL);
141 /*order: o=lp,0*/
142 rRingOrder_t *order = (rRingOrder_t *) omAlloc(2* sizeof(rRingOrder_t));
143 int *block0 = (int *)omAlloc0(2 * sizeof(int));
144 int *block1 = (int *)omAlloc0(2 * sizeof(int));
145 /* ringorder o=lp for the first block: var 1..N */
146 order[0] = o;
147 block0[0] = 1;
148 block1[0] = N;
149 /* the last block: everything is 0 */
150 order[1] = (rRingOrder_t)0;
151
152 return rDefault(cf,N,n,2,order,block0,block1);
153}
CanonicalForm cf
Definition cfModGcd.cc:4083
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition ring.cc:102

◆ rDefault() [2/4]

ring rDefault ( const coeffs  cf,
int  N,
char **  n,
int  ord_size,
rRingOrder_t ord,
int block0,
int block1,
int **  wvhdl = NULL,
unsigned long  bitmask = 0 
)

Definition at line 102 of file ring.cc.

103{
104 assume( cf != NULL);
106 r->N = N;
107 r->cf = cf;
108 /*rPar(r) = 0; Alloc0 */
109 /*names*/
110 r->names = (char **) omAlloc0(N * sizeof(char *));
111 int i;
112 for(i=0;i<N;i++)
113 {
114 r->names[i] = omStrDup(n[i]);
115 }
116 /*weights: entries for 2 blocks: NULL*/
117 if (wvhdl==NULL)
118 r->wvhdl = (int **)omAlloc0((ord_size+1) * sizeof(int *));
119 else
120 r->wvhdl=wvhdl;
121 r->order = ord;
122 r->block0 = block0;
123 r->block1 = block1;
124 if (bitmask!=0) r->wanted_maxExp=bitmask;
125
126 /* complete ring intializations */
127 rComplete(r);
128 return r;
129}

◆ rDefault() [3/4]

ring rDefault ( int  ch,
int  N,
char **  n 
)

Definition at line 155 of file ring.cc.

156{
157 coeffs cf;
158 if (ch==0) cf=nInitChar(n_Q,NULL);
159 else cf=nInitChar(n_Zp,(void*)(long)ch);
160 assume( cf != NULL);
161 return rDefault(cf,N,n);
162}
@ n_Q
rational (GMP) numbers
Definition coeffs.h:30
@ n_Zp
\F{p < 2^31}
Definition coeffs.h:29
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:414

◆ rDefault() [4/4]

ring rDefault ( int  ch,
int  N,
char **  n,
int  ord_size,
rRingOrder_t ord,
int block0,
int block1,
int **  wvhdl = NULL 
)

Definition at line 130 of file ring.cc.

131{
132 coeffs cf;
133 if (ch==0) cf=nInitChar(n_Q,NULL);
134 else cf=nInitChar(n_Zp,(void*)(long)ch);
135 assume( cf != NULL);
136 return rDefault(cf,N,n,ord_size,ord,block0,block1,wvhdl);
137}

◆ rDelete()

void rDelete ( ring  r)

unconditionally deletes fields in r

Definition at line 450 of file ring.cc.

451{
452 int i, j;
453
454 if (r == NULL) return;
455 if( r->ref > 0 ) // ->ref means the number of Interpreter objects referring to the ring...
456 return;
457
458 if( r->qideal != NULL )
459 {
460 ideal q = r->qideal;
461 r->qideal = NULL;
462 id_Delete(&q, r);
463 }
464
465#ifdef HAVE_PLURAL
466 if (rIsPluralRing(r))
467 nc_rKill(r);
468#endif
469
470 rUnComplete(r); // may need r->cf for p_Delete
471 nKillChar(r->cf); r->cf = NULL;
472 // delete order stuff
473 if (r->order != NULL)
474 {
475 i=rBlocks(r);
476 assume(r->block0 != NULL && r->block1 != NULL && r->wvhdl != NULL);
477 // delete order
478 omFreeSize((ADDRESS)r->order,i*sizeof(rRingOrder_t));
479 omFreeSize((ADDRESS)r->block0,i*sizeof(int));
480 omFreeSize((ADDRESS)r->block1,i*sizeof(int));
481 // delete weights
482 for (j=0; j<i; j++)
483 {
484 if (r->wvhdl[j]!=NULL)
485 omFree(r->wvhdl[j]);
486 }
487 omFreeSize((ADDRESS)r->wvhdl,i*sizeof(int *));
488 }
489 else
490 {
491 assume(r->block0 == NULL && r->block1 == NULL && r->wvhdl == NULL);
492 }
493
494 // delete varnames
495 if(r->names!=NULL)
496 {
497 for (i=0; i<r->N; i++)
498 {
499 if (r->names[i] != NULL) omFree((ADDRESS)r->names[i]);
500 }
501 omFreeSize((ADDRESS)r->names,r->N*sizeof(char *));
502 }
503
505}
void nKillChar(coeffs r)
undo all initialisations
Definition numbers.cc:569
void nc_rKill(ring r)
complete destructor
#define omFreeBin(addr, bin)

◆ rEnvelope()

ring rEnvelope ( ring  r)

Definition at line 5732 of file ring.cc.

5735{
5736 ring Ropp = rOpposite(R);
5737 ring Renv = NULL;
5738 int stat = rSum(R, Ropp, Renv); /* takes care of qideals */
5739 if ( stat <=0 )
5740 WarnS("Error in rEnvelope at rSum");
5741 rTest(Renv);
5742 return Renv;
5743}
int rSum(ring r1, ring r2, ring &sum)
Definition ring.cc:1402
ring rOpposite(ring src)
Definition ring.cc:5342
#define R
Definition sirandom.c:27

◆ rEqual()

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

Definition at line 1746 of file ring.cc.

1747{
1748 if (r1 == r2) return TRUE;
1749 if (r1 == NULL || r2 == NULL) return FALSE;
1750 if (r1->cf!=r2->cf) return FALSE;
1751 if (rVar(r1)!=rVar(r2)) return FALSE;
1752 if (r1->bitmask!=r2->bitmask) return FALSE;
1753 #ifdef HAVE_SHIFTBBA
1754 if (r1->isLPring!=r2->isLPring) return FALSE;
1755 if (r1->LPncGenCount!=r2->LPncGenCount) return FALSE;
1756 #endif
1757
1758 if( !rSamePolyRep(r1, r2) )
1759 return FALSE;
1760
1761 int i/*, j*/;
1762
1763 for (i=0; i<rVar(r1); i++)
1764 {
1765 if ((r1->names[i] != NULL) && (r2->names[i] != NULL))
1766 {
1767 if (strcmp(r1->names[i], r2->names[i])) return FALSE;
1768 }
1769 else if ((r1->names[i] != NULL) ^ (r2->names[i] != NULL))
1770 {
1771 return FALSE;
1772 }
1773 }
1774
1775 if (qr)
1776 {
1777 if (r1->qideal != NULL)
1778 {
1779 ideal id1 = r1->qideal, id2 = r2->qideal;
1780 int i, n;
1781 poly *m1, *m2;
1782
1783 if (id2 == NULL) return FALSE;
1784 if ((n = IDELEMS(id1)) != IDELEMS(id2)) return FALSE;
1785
1786 {
1787 m1 = id1->m;
1788 m2 = id2->m;
1789 for (i=0; i<n; i++)
1790 if (! p_EqualPolys(m1[i],m2[i], r1, r2)) return FALSE;
1791 }
1792 }
1793 else if (r2->qideal != NULL) return FALSE;
1794 }
1795
1796 return TRUE;
1797}
Definition qr.h:46
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition p_polys.cc:4512
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...
Definition ring.cc:1799
#define IDELEMS(i)

◆ rField_has_simple_Alloc()

static BOOLEAN rField_has_simple_Alloc ( const ring  r)
inlinestatic

Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.

Definition at line 552 of file ring.h.

553{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_has_simple_Alloc(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete is empty operation.
Definition coeffs.h:903

◆ rField_has_simple_inverse()

static BOOLEAN rField_has_simple_inverse ( const ring  r)
inlinestatic

Definition at line 548 of file ring.h.

549{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_has_simple_inverse(r->cf); }
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.
Definition coeffs.h:899

◆ rField_has_Units()

static BOOLEAN rField_has_Units ( const ring  r)
inlinestatic

Definition at line 490 of file ring.h.

491{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_has_Units(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
Definition coeffs.h:794

◆ rField_is_Domain()

static BOOLEAN rField_is_Domain ( const ring  r)
inlinestatic

Definition at line 487 of file ring.h.

488{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Domain(r->cf); }
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)
Definition coeffs.h:736

◆ rField_is_GF() [1/2]

static BOOLEAN rField_is_GF ( const ring  r)
inlinestatic

Definition at line 521 of file ring.h.

522{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_GF(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition coeffs.h:836

◆ rField_is_GF() [2/2]

static BOOLEAN rField_is_GF ( const ring  r,
int  q 
)
inlinestatic

Definition at line 524 of file ring.h.

525{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_GF(r->cf, q); }

◆ rField_is_long_C()

static BOOLEAN rField_is_long_C ( const ring  r)
inlinestatic

Definition at line 545 of file ring.h.

546{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_long_C(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition coeffs.h:891

◆ rField_is_long_R()

static BOOLEAN rField_is_long_R ( const ring  r)
inlinestatic

Definition at line 542 of file ring.h.

543{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_long_R(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition coeffs.h:888

◆ rField_is_numeric()

static BOOLEAN rField_is_numeric ( const ring  r)
inlinestatic

Definition at line 515 of file ring.h.

516{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_numeric(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition coeffs.h:829

◆ rField_is_Q()

static BOOLEAN rField_is_Q ( const ring  r)
inlinestatic

Definition at line 506 of file ring.h.

507{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Q(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition coeffs.h:803

◆ rField_is_Q_a()

static BOOLEAN rField_is_Q_a ( const ring  r)
inlinestatic

Definition at line 539 of file ring.h.

540{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Q_a(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition coeffs.h:882

◆ rField_is_R()

static BOOLEAN rField_is_R ( const ring  r)
inlinestatic

Definition at line 518 of file ring.h.

519{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_R(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition coeffs.h:833

◆ rField_is_Ring_2toM()

static BOOLEAN rField_is_Ring_2toM ( const ring  r)
inlinestatic

Definition at line 479 of file ring.h.

480{ assume(r != NULL); assume(r->cf != NULL); return ( nCoeff_is_Ring_2toM(r->cf) ); }
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition coeffs.h:721

◆ rField_is_Ring_PtoM()

static BOOLEAN rField_is_Ring_PtoM ( const ring  r)
inlinestatic

Definition at line 482 of file ring.h.

483{ assume(r != NULL); assume(r->cf != NULL); return ( nCoeff_is_Ring_PtoM(r->cf) ); }
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition coeffs.h:724

◆ rField_is_Z()

static BOOLEAN rField_is_Z ( const ring  r)
inlinestatic

Definition at line 509 of file ring.h.

510{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Z(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition coeffs.h:813

◆ rField_is_Zn()

static BOOLEAN rField_is_Zn ( const ring  r)
inlinestatic

Definition at line 512 of file ring.h.

513{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Zn(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
Definition coeffs.h:823

◆ rField_is_Zp() [1/2]

static BOOLEAN rField_is_Zp ( const ring  r)
inlinestatic

Definition at line 500 of file ring.h.

501{ assume(r != NULL); assume(r->cf != NULL); return (getCoeffType(r->cf) == n_Zp); }

◆ rField_is_Zp() [2/2]

static BOOLEAN rField_is_Zp ( const ring  r,
int  p 
)
inlinestatic

Definition at line 503 of file ring.h.

504{ assume(r != NULL); assume(r->cf != NULL); return (getCoeffType(r->cf) == n_Zp) && (r->cf->ch == p); }

◆ rField_is_Zp_a() [1/2]

static BOOLEAN rField_is_Zp_a ( const ring  r)
inlinestatic

Definition at line 529 of file ring.h.

530{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Zp_a(r->cf); }
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition coeffs.h:856

◆ rField_is_Zp_a() [2/2]

static BOOLEAN rField_is_Zp_a ( const ring  r,
int  p 
)
inlinestatic

Definition at line 534 of file ring.h.

535{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Zp_a(r->cf, p); }

◆ rFieldType()

static n_coeffType rFieldType ( const ring  r)
inlinestatic

the type of the coefficient filed of r (n_Zp, n_Q, etc)

Definition at line 556 of file ring.h.

556{ return (r->cf->type); }

◆ rGetCurrSyzLimit()

static int rGetCurrSyzLimit ( const ring  r)
inlinestatic

Definition at line 723 of file ring.h.

724{ assume(r != NULL); assume(r->cf != NULL); return (rIsSyzIndexRing(r)? r->typ[0].data.syz.limit : 0);}
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition ring.h:720

◆ rGetExpSize()

unsigned long rGetExpSize ( unsigned long  bitmask,
int bits,
int  N 
)

Definition at line 2672 of file ring.cc.

2673{
2674 bitmask =rGetExpSize(bitmask, bits);
2676 int bits1;
2677 loop
2678 {
2679 if (bits == BIT_SIZEOF_LONG-1)
2680 {
2681 bits = BIT_SIZEOF_LONG - 1;
2682 return LONG_MAX;
2683 }
2684 unsigned long bitmask1 =rGetExpSize(bitmask+1, bits1);
2686 if ((((N+vars_per_long-1)/vars_per_long) ==
2688 {
2690 bits=bits1;
2691 bitmask=bitmask1;
2692 }
2693 else
2694 {
2695 return bitmask; /* and bits */
2696 }
2697 }
2698}
#define loop
Definition structs.h:75

◆ rGetISPos()

int rGetISPos ( const int  p,
const ring  r 
)

return the position of the p^th IS block order block in r->typ[]...

return the position of the p^th IS block order block in r->typ[]...

Definition at line 5061 of file ring.cc.

5062{
5063 // Put the reference set F into the ring -ordering -recor
5064#if MYTEST
5065 Print("rIsIS(p: %d)\nF:", p);
5066 PrintLn();
5067#endif
5068
5069 if (r->typ==NULL)
5070 {
5071// dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
5072 return -1;
5073 }
5074
5075 int j = p; // Which IS record to use...
5076 for( int pos = 0; pos < r->OrdSize; pos++ )
5077 if( r->typ[pos].ord_typ == ro_is)
5078 if( j-- == 0 )
5079 return pos;
5080
5081 return -1;
5082}

◆ rGetMaxSyzComp()

int rGetMaxSyzComp ( int  i,
const ring  r 
)

return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit

Definition at line 5219 of file ring.cc.

5220{
5221 if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz) &&
5222 r->typ[0].data.syz.limit > 0 && i > 0)
5223 {
5224 assume(i <= r->typ[0].data.syz.limit);
5225 int j;
5226 for (j=0; j<r->typ[0].data.syz.limit; j++)
5227 {
5228 if (r->typ[0].data.syz.syz_index[j] == i &&
5229 r->typ[0].data.syz.syz_index[j+1] != i)
5230 {
5231 assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5232 return j;
5233 }
5234 }
5235 return r->typ[0].data.syz.limit;
5236 }
5237 else
5238 {
5239 #ifndef SING_NDEBUG
5240 WarnS("rGetMaxSyzComp: order c");
5241 #endif
5242 return 0;
5243 }
5244}

◆ rGetOrderType()

rOrderType_t rGetOrderType ( ring  r)

Definition at line 1840 of file ring.cc.

1841{
1842 // check for simple ordering
1843 if (rHasSimpleOrder(r))
1844 {
1845 if ((r->order[1] == ringorder_c)
1846 || (r->order[1] == ringorder_C))
1847 {
1848 switch(r->order[0])
1849 {
1850 case ringorder_dp:
1851 case ringorder_wp:
1852 case ringorder_ds:
1853 case ringorder_ws:
1854 case ringorder_ls:
1855 case ringorder_unspec:
1856 if (r->order[1] == ringorder_C
1857 || r->order[0] == ringorder_unspec)
1858 return rOrderType_ExpComp;
1859 return rOrderType_Exp;
1860
1861 default:
1862 assume(r->order[0] == ringorder_lp ||
1863 r->order[0] == ringorder_rs ||
1864 r->order[0] == ringorder_Dp ||
1865 r->order[0] == ringorder_Wp ||
1866 r->order[0] == ringorder_Ds ||
1867 r->order[0] == ringorder_Ws);
1868
1869 if (r->order[1] == ringorder_c) return rOrderType_ExpComp;
1870 return rOrderType_Exp;
1871 }
1872 }
1873 else
1874 {
1875 assume((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C));
1876 return rOrderType_CompExp;
1877 }
1878 }
1879 else
1880 return rOrderType_General;
1881}
BOOLEAN rHasSimpleOrder(const ring r)
Definition ring.cc:1887

◆ rGetSComps()

void rGetSComps ( int **  currComponents,
long **  currShiftedComponents,
int length,
ring  r 
)

Definition at line 4423 of file ring.cc.

4424{
4425#ifdef PDEBUG
4427#else
4429#endif
4430}
static void rNGetSComps(int **currComponents, long **currShiftedComponents, ring r)
Definition ring.cc:4384
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition ring.cc:4402

◆ rGetVar()

poly rGetVar ( const int  varIndex,
const ring  r 
)

Definition at line 5824 of file ring.cc.

5825{
5826 poly p = p_ISet(1, r);
5827 p_SetExp(p, varIndex, 1, r);
5828 p_Setm(p, r);
5829 return p;
5830}
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition p_polys.cc:1297
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition p_polys.h:488
static void p_Setm(poly p, const ring r)
Definition p_polys.h:233

◆ rGetWeightVec()

int64 * rGetWeightVec ( const ring  r)

Definition at line 5283 of file ring.cc.

5284{
5285 assume(r!=NULL);
5286 assume(r->OrdSize>0);
5287 int i=0;
5288 while((r->typ[i].ord_typ!=ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5289 if (r->typ[i].ord_typ!=ro_wp64) return NULL; /* should not happen*/
5290 return r->typ[i].data.wp64.weights64;
5291}

◆ rHas_c_Ordering()

BOOLEAN rHas_c_Ordering ( const ring  r)

Definition at line 1883 of file ring.cc.

1884{
1885 return (r->order[0] == ringorder_c);
1886}

◆ rHasGlobalOrdering()

BOOLEAN rHasGlobalOrdering ( const ring  r)
inline

Definition at line 761 of file ring.h.

761{ return (r->OrdSgn==1); }

◆ rHasLocalOrMixedOrdering()

BOOLEAN rHasLocalOrMixedOrdering ( const ring  r)
inline

Definition at line 762 of file ring.h.

762{ return (r->OrdSgn==-1); }

◆ rHasMixedOrdering()

BOOLEAN rHasMixedOrdering ( const ring  r)
inline

Definition at line 763 of file ring.h.

763{ return (r->MixedOrder); }

◆ rHasSimpleLexOrder()

BOOLEAN rHasSimpleLexOrder ( const ring  r)

returns TRUE, if simple lp or ls ordering

Definition at line 1919 of file ring.cc.

1920{
1921 return rHasSimpleOrder(r) &&
1922 (r->order[0] == ringorder_ls ||
1923 r->order[0] == ringorder_lp ||
1924 r->order[1] == ringorder_ls ||
1925 r->order[1] == ringorder_lp);
1926}

◆ rHasSimpleOrder()

BOOLEAN rHasSimpleOrder ( const ring  r)

Definition at line 1887 of file ring.cc.

1888{
1889 if (r->order[0] == ringorder_unspec) return TRUE;
1890 int blocks = rBlocks(r) - 1;
1891 assume(blocks >= 1);
1892 if (blocks == 1) return TRUE;
1893
1894 int s = 0;
1895 while( (s < blocks) && (r->order[s] == ringorder_IS) && (r->order[blocks-1] == ringorder_IS) )
1896 {
1897 s++;
1898 blocks--;
1899 }
1900
1901 if ((blocks - s) > 2) return FALSE;
1902
1903 assume( blocks == s + 2 );
1904
1905 if (
1906 (r->order[s] != ringorder_c)
1907 && (r->order[s] != ringorder_C)
1908 && (r->order[s+1] != ringorder_c)
1909 && (r->order[s+1] != ringorder_C)
1910 )
1911 return FALSE;
1912 if ((r->order[s+1] == ringorder_M)
1913 || (r->order[s] == ringorder_M))
1914 return FALSE;
1915 return TRUE;
1916}

◆ rIncRefCnt()

static ring rIncRefCnt ( ring  r)
inlinestatic

Definition at line 840 of file ring.h.

840{ r->ref++; return r; }

◆ rInternalChar()

static int rInternalChar ( const ring  r)
inlinestatic

Definition at line 689 of file ring.h.

690{
691 assume(r != NULL);
692 const coeffs C = r->cf;
693 assume(C != NULL);
694 return C->ch;
695}

◆ rIsLPRing()

static BOOLEAN rIsLPRing ( const ring  r)
inlinestatic

Definition at line 411 of file ring.h.

412{
413 assume(r != NULL);
414#ifdef HAVE_SHIFTBBA
415 return (r->isLPring!=0);
416#else
417 return FALSE;
418#endif
419}

◆ rIsNCRing()

static BOOLEAN rIsNCRing ( const ring  r)
inlinestatic

Definition at line 421 of file ring.h.

422{
423 assume(r != NULL);
424 return rIsPluralRing(r) || rIsLPRing(r);
425}
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:411

◆ rIsPluralRing()

static BOOLEAN rIsPluralRing ( const ring  r)
inlinestatic

we must always have this test!

Definition at line 400 of file ring.h.

401{
402 assume(r != NULL);
403#ifdef HAVE_PLURAL
404 nc_struct *n;
405 return ((n=r->GetNC()) != NULL) /*&& (n->type != nc_error)*/;
406#else
407 return FALSE;
408#endif
409}

◆ rIsRatGRing()

static BOOLEAN rIsRatGRing ( const ring  r)
inlinestatic

Definition at line 427 of file ring.h.

428{
429 assume(r != NULL);
430#ifdef HAVE_PLURAL
431 /* nc_struct *n; */
432 return (r != NULL) /* && ((n=r->GetNC()) != NULL) */
433 && (r->real_var_start>1);
434#else
435 return FALSE;
436#endif
437}

◆ rIsSyzIndexRing()

static BOOLEAN rIsSyzIndexRing ( const ring  r)
inlinestatic

Definition at line 720 of file ring.h.

721{ assume(r != NULL); assume(r->cf != NULL); return r->order[0] == ringorder_s;}

◆ rKillModified_Wp_Ring()

void rKillModified_Wp_Ring ( ring  r)

Definition at line 3078 of file ring.cc.

3079{
3080 rUnComplete(r);
3081 omFree(r->order);
3082 omFree(r->block0);
3083 omFree(r->block1);
3084 omFree(r->wvhdl[0]);
3085 omFree(r->wvhdl);
3087}

◆ rKillModifiedRing()

void rKillModifiedRing ( ring  r)

Definition at line 3068 of file ring.cc.

3069{
3070 rUnComplete(r);
3071 omFree(r->order);
3072 omFree(r->block0);
3073 omFree(r->block1);
3074 omFree(r->wvhdl);
3076}

◆ rMinpolyIsNULL()

static BOOLEAN rMinpolyIsNULL ( const ring  r)
inlinestatic

Tests whether '(r->cf->minpoly) == NULL'.

Definition at line 699 of file ring.h.

700{
701 assume(r != NULL);
702 const coeffs C = r->cf;
703 assume(C != NULL);
704
705 const BOOLEAN ret = nCoeff_is_algExt(C); // || nCoeff_is_GF(C) || nCoeff_is_long_C(C);
706
707 if( ret )
708 {
709 assume( (C->extRing) != NULL );
711 assume((!((C->extRing)->qideal==NULL)) && (!idIs0((C->extRing)->qideal)));
712 }
713
714 // TODO: this leads to test fails (due to rDecompose?)
715 return !ret;
716}
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
STATIC_VAR Poly * h
Definition janet.cc:971

◆ rMinusVar()

ring rMinusVar ( const ring  r,
char v 
)

undo rPlusVar

Definition at line 5937 of file ring.cc.

5938{
5939 if (r->order[2]!=0)
5940 {
5941 WerrorS("only for rings with an ordering of one block");
5942 return NULL;
5943 }
5944 int p;
5945 if((r->order[0]==ringorder_C)
5946 ||(r->order[0]==ringorder_c))
5947 p=1;
5948 else
5949 p=0;
5950 if((r->order[p]!=ringorder_dp)
5951 && (r->order[p]!=ringorder_Dp)
5952 && (r->order[p]!=ringorder_lp)
5953 && (r->order[p]!=ringorder_rp)
5954 && (r->order[p]!=ringorder_ds)
5955 && (r->order[p]!=ringorder_Ds)
5956 && (r->order[p]!=ringorder_ls))
5957 {
5958 WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5959 return NULL;
5960 }
5961 ring R=rCopy0(r);
5962 int i=R->N-1;
5963 while(i>=0)
5964 {
5965 if (strcmp(R->names[i],v)==0)
5966 {
5967 R->N--;
5968 omFree(R->names[i]);
5969 for(int j=i;j<R->N;j++) R->names[j]=R->names[j+1];
5970 R->names=(char**)omReallocSize(R->names,r->N*sizeof(char_ptr),R->N*sizeof(char_ptr));
5971 }
5972 i--;
5973 }
5974 R->block1[p]=R->N;
5975 rComplete(R,1);
5976 return R;
5977}
#define omReallocSize(addr, o_size, size)
char * char_ptr
Definition ring.cc:42

◆ rModifyRing()

ring rModifyRing ( ring  r,
BOOLEAN  omit_degree,
BOOLEAN  omit_comp,
unsigned long  exp_limit 
)

< How many induced ordering block do we have?

Definition at line 2707 of file ring.cc.

2710{
2711 assume (r != NULL );
2712 assume (exp_limit > 1);
2714
2715 int bits;
2717 BOOLEAN need_other_ring = (exp_limit != r->bitmask);
2718
2719 int iNeedInducedOrderingSetup = 0; ///< How many induced ordering block do we have?
2720
2721 int nblocks=rBlocks(r);
2723 int *block0=(int*)omAlloc0((nblocks+1)*sizeof(int));
2724 int *block1=(int*)omAlloc0((nblocks+1)*sizeof(int));
2725 int **wvhdl=(int**)omAlloc0((nblocks+1)*sizeof(int *));
2726
2727 int i=0;
2728 int j=0; /* i index in r, j index in res */
2729
2730 for( rRingOrder_t r_ord=r->order[i]; (r_ord != (rRingOrder_t)0) && (i < nblocks); j++, r_ord=r->order[++i])
2731 {
2733
2734 if (r->block0[i]==r->block1[i])
2735 {
2736 switch(r_ord)
2737 {
2738 case ringorder_wp:
2739 case ringorder_dp:
2740 case ringorder_Wp:
2741 case ringorder_Dp:
2743 break;
2744 case ringorder_Ws:
2745 case ringorder_Ds:
2746 case ringorder_ws:
2747 case ringorder_ds:
2749 break;
2750 default:
2751 break;
2752 }
2753 }
2754 switch(r_ord)
2755 {
2756 case ringorder_S:
2757 {
2758#ifndef SING_NDEBUG
2759 Warn("Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2760#endif
2761 order[j]=r_ord; /*r->order[i];*/
2762 break;
2763 }
2764 case ringorder_C:
2765 case ringorder_c:
2766 if (!try_omit_comp)
2767 {
2768 order[j]=r_ord; /*r->order[i]*/;
2769 }
2770 else
2771 {
2772 j--;
2776 }
2777 break;
2778 case ringorder_wp:
2779 case ringorder_dp:
2780 case ringorder_ws:
2781 case ringorder_ds:
2782 if(!omit_degree)
2783 {
2784 order[j]=r_ord; /*r->order[i]*/;
2785 }
2786 else
2787 {
2788 order[j]=ringorder_rs;
2792 }
2793 break;
2794 case ringorder_Wp:
2795 case ringorder_Dp:
2796 case ringorder_Ws:
2797 case ringorder_Ds:
2798 if(!omit_degree)
2799 {
2800 order[j]=r_ord; /*r->order[i];*/
2801 }
2802 else
2803 {
2804 order[j]=ringorder_lp;
2808 }
2809 break;
2810 case ringorder_IS:
2811 {
2812 if (try_omit_comp)
2813 {
2814 // tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_IS)", i, r_ord
2816 }
2817 order[j]=r_ord; /*r->order[i];*/
2819 break;
2820 }
2821 case ringorder_s:
2822 {
2823 assume((i == 0) && (j == 0));
2824 if (try_omit_comp)
2825 {
2826 // tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_s)", i, r_ord
2828 }
2829 order[j]=r_ord; /*r->order[i];*/
2830 break;
2831 }
2832 default:
2833 order[j]=r_ord; /*r->order[i];*/
2834 break;
2835 }
2836 if (copy_block_index)
2837 {
2838 block0[j]=r->block0[i];
2839 block1[j]=r->block1[i];
2840 wvhdl[j]=r->wvhdl[i];
2841 }
2842
2843 // order[j]=ringorder_no; // done by omAlloc0
2844 }
2845 if(!need_other_ring)
2846 {
2847 omFreeSize(order,(nblocks+1)*sizeof(rRingOrder_t));
2848 omFreeSize(block0,(nblocks+1)*sizeof(int));
2849 omFreeSize(block1,(nblocks+1)*sizeof(int));
2850 omFreeSize(wvhdl,(nblocks+1)*sizeof(int *));
2851 return r;
2852 }
2854 *res = *r;
2855
2856#ifdef HAVE_PLURAL
2857 res->GetNC() = NULL;
2858#endif
2859
2860 // res->qideal, res->idroot ???
2861 res->wvhdl=wvhdl;
2862 res->order=order;
2863 res->block0=block0;
2864 res->block1=block1;
2865 res->bitmask=exp_limit;
2866 res->wanted_maxExp=r->wanted_maxExp;
2867 //int tmpref=r->cf->ref0;
2868 rComplete(res, 1);
2869 //r->cf->ref=tmpref;
2870
2871 // adjust res->pFDeg: if it was changed globally, then
2872 // it must also be changed for new ring
2873 if (r->pFDegOrig != res->pFDegOrig &&
2875 {
2876 // still might need adjustment for weighted orderings
2877 // and omit_degree
2878 res->firstwv = r->firstwv;
2879 res->firstBlockEnds = r->firstBlockEnds;
2880 res->pFDeg = res->pFDegOrig = p_WFirstTotalDegree;
2881 }
2882 if (omitted_degree)
2883 res->pLDeg = r->pLDegOrig;
2884
2885 rOptimizeLDeg(res); // also sets res->pLDegOrig
2886
2887 // set syzcomp
2888 if (res->typ != NULL)
2889 {
2890 if( res->typ[0].ord_typ == ro_syz) // "s" Always on [0] place!
2891 {
2892 res->typ[0] = r->typ[0]; // Copy struct!? + setup the same limit!
2893
2894 if (r->typ[0].data.syz.limit > 0)
2895 {
2896 res->typ[0].data.syz.syz_index
2897 = (int*) omAlloc((r->typ[0].data.syz.limit +1)*sizeof(int));
2898 memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2899 (r->typ[0].data.syz.limit +1)*sizeof(int));
2900 }
2901 }
2902
2904 {
2905 for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
2906 if( res->typ[i].ord_typ == ro_is ) // Search for suffixes!
2907 {
2908 ideal F = idrHeadR(r->typ[i].data.is.F, r, res); // Copy F from r into res!
2909 assume(
2911 F, // WILL BE COPIED!
2912 r->typ[i].data.is.limit,
2913 j++
2914 )
2915 );
2916 id_Delete(&F, res);
2918 }
2919 } // Process all induced Ordering blocks! ...
2920 }
2921 // the special case: homog (omit_degree) and 1 block rs: that is global:
2922 // it comes from dp
2923 res->OrdSgn=r->OrdSgn;
2924
2925
2926#ifdef HAVE_PLURAL
2927 if (rIsPluralRing(r))
2928 {
2929 if ( nc_rComplete(r, res, false) ) // no qideal!
2930 {
2931#ifndef SING_NDEBUG
2932 WarnS("error in nc_rComplete");
2933#endif
2934 // cleanup?
2935
2936// rDelete(res);
2937// return r;
2938
2939 // just go on..
2940 }
2941
2942 if( rIsSCA(r) )
2943 {
2945 WarnS("error in sca_Force!");
2946 }
2947 }
2948#endif
2949
2950 return res;
2951}
#define Warn
Definition emacs.cc:77
bool sca_Force(ring rGR, int b, int e)
Definition sca.cc:1159
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
Definition prCopy.cc:156
BOOLEAN rSetISReference(const ring r, const ideal F, const int i, const int p)
Changes r by setting induced ordering parameters: limit and reference leading terms F belong to r,...
Definition ring.cc:5093
static void rOptimizeLDeg(ring r)
Definition ring.cc:3159
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
Definition ring.cc:2036
static short scaLastAltVar(ring r)
Definition sca.h:25
static short scaFirstAltVar(ring r)
Definition sca.h:18

◆ rModifyRing_Simple()

ring rModifyRing_Simple ( ring  r,
BOOLEAN  omit_degree,
BOOLEAN  omit_comp,
unsigned long  exp_limit,
BOOLEAN simple 
)

Definition at line 3002 of file ring.cc.

3003{
3004 simple=TRUE;
3005 if (!rHasSimpleOrder(r))
3006 {
3007 simple=FALSE; // sorting needed
3008 assume (r != NULL );
3009 assume (exp_limit > 1);
3010 int bits;
3011
3013
3014 int nblocks=1+(ommit_comp!=0);
3016 int *block0=(int*)omAlloc0((nblocks+1)*sizeof(int));
3017 int *block1=(int*)omAlloc0((nblocks+1)*sizeof(int));
3018 int **wvhdl=(int**)omAlloc0((nblocks+1)*sizeof(int *));
3019
3020 order[0]=ringorder_lp;
3021 block0[0]=1;
3022 block1[0]=r->N;
3023 if (!ommit_comp)
3024 {
3025 order[1]=ringorder_C;
3026 }
3028 *res = *r;
3029#ifdef HAVE_PLURAL
3030 res->GetNC() = NULL;
3031#endif
3032 // res->qideal, res->idroot ???
3033 res->wvhdl=wvhdl;
3034 res->order=order;
3035 res->block0=block0;
3036 res->block1=block1;
3037 res->bitmask=exp_limit;
3038 res->wanted_maxExp=r->wanted_maxExp;
3039 //int tmpref=r->cf->ref;
3040 rComplete(res, 1);
3041 //r->cf->ref=tmpref;
3042
3043#ifdef HAVE_PLURAL
3044 if (rIsPluralRing(r))
3045 {
3046 if ( nc_rComplete(r, res, false) ) // no qideal!
3047 {
3048#ifndef SING_NDEBUG
3049 WarnS("error in nc_rComplete");
3050#endif
3051 // cleanup?
3052
3053// rDelete(res);
3054// return r;
3055
3056 // just go on..
3057 }
3058 }
3059#endif
3060
3062
3063 return res;
3064 }
3066}
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
Definition ring.cc:2707

◆ rModifyRing_Wp()

ring rModifyRing_Wp ( ring  r,
int weights 
)

construct Wp, C ring

Definition at line 2954 of file ring.cc.

2955{
2957 *res = *r;
2958#ifdef HAVE_PLURAL
2959 res->GetNC() = NULL;
2960#endif
2961
2962 /*weights: entries for 3 blocks: NULL*/
2963 res->wvhdl = (int **)omAlloc0(3 * sizeof(int *));
2964 /*order: Wp,C,0*/
2965 res->order = (rRingOrder_t *) omAlloc(3 * sizeof(rRingOrder_t *));
2966 res->block0 = (int *)omAlloc0(3 * sizeof(int *));
2967 res->block1 = (int *)omAlloc0(3 * sizeof(int *));
2968 /* ringorder Wp for the first block: var 1..r->N */
2969 res->order[0] = ringorder_Wp;
2970 res->block0[0] = 1;
2971 res->block1[0] = r->N;
2972 res->wvhdl[0] = weights;
2973 /* ringorder C for the second block: no vars */
2974 res->order[1] = ringorder_C;
2975 /* the last block: everything is 0 */
2976 res->order[2] = (rRingOrder_t)0;
2977
2978 //int tmpref=r->cf->ref;
2979 rComplete(res, 1);
2980 //r->cf->ref=tmpref;
2981#ifdef HAVE_PLURAL
2982 if (rIsPluralRing(r))
2983 {
2984 if ( nc_rComplete(r, res, false) ) // no qideal!
2985 {
2986#ifndef SING_NDEBUG
2987 WarnS("error in nc_rComplete");
2988#endif
2989 // cleanup?
2990
2991// rDelete(res);
2992// return r;
2993
2994 // just go on..
2995 }
2996 }
2997#endif
2998 return res;
2999}

◆ rOpposite()

ring rOpposite ( ring  r)

Definition at line 5342 of file ring.cc.

5346{
5347 if (src == NULL) return(NULL);
5348
5349 //rChangeCurrRing(src);
5350#ifdef RDEBUG
5351 rTest(src);
5352// rWrite(src);
5353// rDebugPrint(src);
5354#endif
5355
5356 ring r = rCopy0(src,FALSE);
5357 if (src->qideal != NULL)
5358 {
5359 id_Delete(&(r->qideal), src);
5360 }
5361
5362 // change vars v1..vN -> vN..v1
5363 int i;
5364 int i2 = (rVar(r)-1)/2;
5365 for(i=i2; i>=0; i--)
5366 {
5367 // index: 0..N-1
5368 //Print("ex var names: %d <-> %d\n",i,rOppVar(r,i));
5369 // exchange names
5370 char *p;
5371 p = r->names[rVar(r)-1-i];
5372 r->names[rVar(r)-1-i] = r->names[i];
5373 r->names[i] = p;
5374 }
5375// i2=(rVar(r)+1)/2;
5376// for(int i=i2; i>0; i--)
5377// {
5378// // index: 1..N
5379// //Print("ex var places: %d <-> %d\n",i,rVar(r)+1-i);
5380// // exchange VarOffset
5381// int t;
5382// t=r->VarOffset[i];
5383// r->VarOffset[i]=r->VarOffset[rOppVar(r,i)];
5384// r->VarOffset[rOppVar(r,i)]=t;
5385// }
5386 // change names:
5387 // TODO: does this work the same way for Letterplace?
5388 for (i=rVar(r)-1; i>=0; i--)
5389 {
5390 char *p=r->names[i];
5391 if(isupper(*p)) *p = tolower(*p);
5392 else *p = toupper(*p);
5393 }
5394 // change ordering: listing
5395 // change ordering: compare
5396// for(i=0; i<r->OrdSize; i++)
5397// {
5398// int t,tt;
5399// switch(r->typ[i].ord_typ)
5400// {
5401// case ro_dp:
5402// //
5403// t=r->typ[i].data.dp.start;
5404// r->typ[i].data.dp.start=rOppVar(r,r->typ[i].data.dp.end);
5405// r->typ[i].data.dp.end=rOppVar(r,t);
5406// break;
5407// case ro_wp:
5408// case ro_wp_neg:
5409// {
5410// t=r->typ[i].data.wp.start;
5411// r->typ[i].data.wp.start=rOppVar(r,r->typ[i].data.wp.end);
5412// r->typ[i].data.wp.end=rOppVar(r,t);
5413// // invert r->typ[i].data.wp.weights
5414// rOppWeight(r->typ[i].data.wp.weights,
5415// r->typ[i].data.wp.end-r->typ[i].data.wp.start);
5416// break;
5417// }
5418// //case ro_wp64:
5419// case ro_syzcomp:
5420// case ro_syz:
5421// WerrorS("not implemented in rOpposite");
5422// // should not happen
5423// break;
5424//
5425// case ro_cp:
5426// t=r->typ[i].data.cp.start;
5427// r->typ[i].data.cp.start=rOppVar(r,r->typ[i].data.cp.end);
5428// r->typ[i].data.cp.end=rOppVar(r,t);
5429// break;
5430// case ro_none:
5431// default:
5432// Werror("unknown type in rOpposite(%d)",r->typ[i].ord_typ);
5433// break;
5434// }
5435// }
5436 // Change order/block structures (needed for rPrint, rAdd etc.)
5437
5438 int j=0;
5439 int l=rBlocks(src);
5440 if ( ! rIsLPRing(src) )
5441 {
5442 // ie Plural or commutative
5443 for(i=0; src->order[i]!=0; i++)
5444 {
5445 switch (src->order[i])
5446 {
5447 case ringorder_c: /* c-> c */
5448 case ringorder_C: /* C-> C */
5449 case ringorder_no /*=0*/: /* end-of-block */
5450 r->order[j]=src->order[i];
5451 j++; break;
5452 case ringorder_lp: /* lp -> rp */
5453 r->order[j]=ringorder_rp;
5454 r->block0[j]=rOppVar(r, src->block1[i]);
5455 r->block1[j]=rOppVar(r, src->block0[i]);
5456 j++;break;
5457 case ringorder_rp: /* rp -> lp */
5458 r->order[j]=ringorder_lp;
5459 r->block0[j]=rOppVar(r, src->block1[i]);
5460 r->block1[j]=rOppVar(r, src->block0[i]);
5461 j++;break;
5462 case ringorder_dp: /* dp -> a(1..1),ls */
5463 {
5464 l=rRealloc1(r,l,j);
5465 r->order[j]=ringorder_a;
5466 r->block0[j]=rOppVar(r, src->block1[i]);
5467 r->block1[j]=rOppVar(r, src->block0[i]);
5468 r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
5469 for(int k=r->block0[j]; k<=r->block1[j]; k++)
5470 r->wvhdl[j][k-r->block0[j]]=1;
5471 j++;
5472 r->order[j]=ringorder_ls;
5473 r->block0[j]=rOppVar(r, src->block1[i]);
5474 r->block1[j]=rOppVar(r, src->block0[i]);
5475 j++;
5476 break;
5477 }
5478 case ringorder_Dp: /* Dp -> a(1..1),rp */
5479 {
5480 l=rRealloc1(r,l,j);
5481 r->order[j]=ringorder_a;
5482 r->block0[j]=rOppVar(r, src->block1[i]);
5483 r->block1[j]=rOppVar(r, src->block0[i]);
5484 r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
5485 for(int k=r->block0[j]; k<=r->block1[j]; k++)
5486 r->wvhdl[j][k-r->block0[j]]=1;
5487 j++;
5488 r->order[j]=ringorder_rp;
5489 r->block0[j]=rOppVar(r, src->block1[i]);
5490 r->block1[j]=rOppVar(r, src->block0[i]);
5491 j++;
5492 break;
5493 }
5494 case ringorder_wp: /* wp -> a(...),ls */
5495 {
5496 l=rRealloc1(r,l,j);
5497 r->order[j]=ringorder_a;
5498 r->block0[j]=rOppVar(r, src->block1[i]);
5499 r->block1[j]=rOppVar(r, src->block0[i]);
5500 r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
5501 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5502 j++;
5503 r->order[j]=ringorder_ls;
5504 r->block0[j]=rOppVar(r, src->block1[i]);
5505 r->block1[j]=rOppVar(r, src->block0[i]);
5506 j++;
5507 break;
5508 }
5509 case ringorder_Wp: /* Wp -> a(...),rp */
5510 {
5511 l=rRealloc1(r,l,j);
5512 r->order[j]=ringorder_a;
5513 r->block0[j]=rOppVar(r, src->block1[i]);
5514 r->block1[j]=rOppVar(r, src->block0[i]);
5515 r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
5516 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5517 j++;
5518 r->order[j]=ringorder_rp;
5519 r->block0[j]=rOppVar(r, src->block1[i]);
5520 r->block1[j]=rOppVar(r, src->block0[i]);
5521 j++;
5522 break;
5523 }
5524 case ringorder_M: /* M -> M */
5525 {
5526 r->order[j]=ringorder_M;
5527 r->block0[j]=rOppVar(r, src->block1[i]);
5528 r->block1[j]=rOppVar(r, src->block0[i]);
5529 int n=r->block1[j]-r->block0[j];
5530 /* M is a (n+1)x(n+1) matrix */
5531 for (int nn=0; nn<=n; nn++)
5532 {
5533 rOppWeight(&(r->wvhdl[j][nn*(n+1)]), n /*r->block1[j]-r->block0[j]*/);
5534 }
5535 j++;
5536 break;
5537 }
5538 case ringorder_a: /* a(...),ls -> wp/dp */
5539 {
5540 r->block0[j]=rOppVar(r, src->block1[i]);
5541 r->block1[j]=rOppVar(r, src->block0[i]);
5542 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5543 if (src->order[i+1]==ringorder_ls)
5544 {
5545 r->order[j]=ringorder_wp;
5546 i++;
5547 //l=rReallocM1(r,l,j);
5548 }
5549 else
5550 {
5551 r->order[j]=ringorder_a;
5552 }
5553 j++;
5554 break;
5555 }
5556 // not yet done:
5557 case ringorder_ls:
5558 case ringorder_rs:
5559 case ringorder_ds:
5560 case ringorder_Ds:
5561 case ringorder_ws:
5562 case ringorder_Ws:
5563 case ringorder_am:
5564 case ringorder_a64:
5565 // should not occur:
5566 case ringorder_S:
5567 case ringorder_IS:
5568 case ringorder_s:
5569 case ringorder_aa:
5570 case ringorder_L:
5571 case ringorder_unspec:
5572 Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5573 break;
5574 }
5575 }
5576 } /* end if (!rIsLPRing(src)) */
5577 if (rIsLPRing(src))
5578 {
5579 // applies to Letterplace only
5580 // Letterplace conventions: dp<->Dp, lp<->rp
5581 // Wp(v) cannot be converted since wp(v) does not encode a monomial ordering
5582 // (a(w),<) is troublesome and thus postponed
5583 for(i=0; src->order[i]!=0; i++)
5584 {
5585 switch (src->order[i])
5586 {
5587 case ringorder_c: /* c-> c */
5588 case ringorder_C: /* C-> C */
5589 case ringorder_no /*=0*/: /* end-of-block */
5590 r->order[j]=src->order[i];
5591 j++; break;
5592 case ringorder_lp: /* lp -> rp */
5593 r->order[j]=ringorder_rp;
5594 r->block0[j]=rOppVar(r, src->block1[i]);
5595 r->block1[j]=rOppVar(r, src->block0[i]);
5596 j++;break;
5597 case ringorder_rp: /* rp -> lp */
5598 r->order[j]=ringorder_lp;
5599 r->block0[j]=rOppVar(r, src->block1[i]);
5600 r->block1[j]=rOppVar(r, src->block0[i]);
5601 j++;break;
5602 case ringorder_dp: /* dp -> Dp */
5603 {
5604 r->order[j]=ringorder_Dp;
5605 r->block0[j]=rOppVar(r, src->block1[i]);
5606 r->block1[j]=rOppVar(r, src->block0[i]);
5607 j++;break;
5608 }
5609 case ringorder_Dp: /* Dp -> dp*/
5610 {
5611 r->order[j]=ringorder_dp;
5612 r->block0[j]=rOppVar(r, src->block1[i]);
5613 r->block1[j]=rOppVar(r, src->block0[i]);
5614 j++;break;
5615 }
5616 // not clear how to do:
5617 case ringorder_wp:
5618 case ringorder_Wp:
5619 case ringorder_M:
5620 case ringorder_a:
5621 // not yet done:
5622 case ringorder_ls:
5623 case ringorder_rs:
5624 case ringorder_ds:
5625 case ringorder_Ds:
5626 case ringorder_ws:
5627 case ringorder_Ws:
5628 case ringorder_am:
5629 case ringorder_a64:
5630 // should not occur:
5631 case ringorder_S:
5632 case ringorder_IS:
5633 case ringorder_s:
5634 case ringorder_aa:
5635 case ringorder_L:
5636 case ringorder_unspec:
5637 Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5638 break;
5639 }
5640 }
5641 } /* end if (rIsLPRing(src)) */
5642 rComplete(r);
5643
5644 //rChangeCurrRing(r);
5645#ifdef RDEBUG
5646 rTest(r);
5647// rWrite(r);
5648// rDebugPrint(r);
5649#endif
5650
5651#ifdef HAVE_PLURAL
5652 // now, we initialize a non-comm structure on r
5653 if (rIsPluralRing(src))
5654 {
5655// assume( currRing == r);
5656
5657 int *perm = (int *)omAlloc0((rVar(r)+1)*sizeof(int));
5658 int *par_perm = NULL;
5659 nMapFunc nMap = n_SetMap(src->cf,r->cf);
5660 int ni,nj;
5661 for(i=1; i<=r->N; i++)
5662 {
5663 perm[i] = rOppVar(r,i);
5664 }
5665
5666 matrix C = mpNew(rVar(r),rVar(r));
5667 matrix D = mpNew(rVar(r),rVar(r));
5668
5669 for (i=1; i< rVar(r); i++)
5670 {
5671 for (j=i+1; j<=rVar(r); j++)
5672 {
5673 ni = r->N +1 - i;
5674 nj = r->N +1 - j; /* i<j ==> nj < ni */
5675
5676 assume(MATELEM(src->GetNC()->C,i,j) != NULL);
5677 MATELEM(C,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,r, nMap,par_perm,rPar(src));
5678
5679 if(MATELEM(src->GetNC()->D,i,j) != NULL)
5680 MATELEM(D,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,r, nMap,par_perm,rPar(src));
5681 }
5682 }
5683
5684 id_Test((ideal)C, r);
5685 id_Test((ideal)D, r);
5686
5687 if (nc_CallPlural(C, D, NULL, NULL, r, false, false, true, r)) // no qring setup!
5688 WarnS("Error initializing non-commutative multiplication!");
5689
5690#ifdef RDEBUG
5691 rTest(r);
5692// rWrite(r);
5693// rDebugPrint(r);
5694#endif
5695
5696 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5697
5698 omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
5699 }
5700#endif /* HAVE_PLURAL */
5701
5702 /* now oppose the qideal for qrings */
5703 if (src->qideal != NULL)
5704 {
5705#ifdef HAVE_PLURAL
5706 r->qideal = idOppose(src, src->qideal, r); // into the currRing: r
5707#else
5708 r->qideal = id_Copy(src->qideal, r); // ?
5709#endif
5710
5711#ifdef HAVE_PLURAL
5712 if( rIsPluralRing(r) )
5713 {
5715#ifdef RDEBUG
5716 rTest(r);
5717// rWrite(r);
5718// rDebugPrint(r);
5719#endif
5720 }
5721#endif
5722 }
5723#ifdef HAVE_PLURAL
5724 if( rIsPluralRing(r) )
5725 assume( ncRingType(r) == ncRingType(src) );
5726#endif
5727 rTest(r);
5728
5729 return r;
5730}
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition coeffs.h:697
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:73
#define D(A)
Definition gentable.cc:131
ideal id_Copy(ideal h1, const ring r)
copy an ideal
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
BOOLEAN nc_CallPlural(matrix cc, matrix dd, poly cn, poly dn, ring r, bool bSetupQuotient, bool bCopyInput, bool bBeQuiet, ring curr, bool dummy_ring=false)
returns TRUE if there were errors analyze inputs, check them for consistency detects nc_type,...
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition matpol.cc:37
#define MATELEM(mat, i, j)
1-based access to matrix
Definition matpol.h:29
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4130
#define rOppVar(R, I)
Definition ring.cc:5339
const char * rSimpleOrdStr(int ord)
Definition ring.cc:77
static void rOppWeight(int *w, int l)
Definition ring.cc:5326
static int rRealloc1(ring r, int size, int pos)
Definition ring.cc:5303
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:599
#define id_Test(A, lR)

◆ rOrd_is_Comp_dp()

static BOOLEAN rOrd_is_Comp_dp ( const ring  r)
inlinestatic

Definition at line 775 of file ring.h.

776{
777 assume(r != NULL);
778 assume(r->cf != NULL);
779 return ((r->order[0] == ringorder_c || r->order[0] == ringorder_C) &&
780 r->order[1] == ringorder_dp &&
781 r->order[2] == 0);
782}

◆ rOrd_is_dp()

BOOLEAN rOrd_is_dp ( const ring  r)

Definition at line 2026 of file ring.cc.

2027{
2028 // Hmm.... what about Syz orderings?
2029 return (rVar(r) > 1 &&
2030 (rHasSimpleOrder(r) &&
2031 (r->order[0]==ringorder_dp) ||
2032 (r->order[1]==ringorder_dp)));
2033}

◆ rOrd_is_Totaldegree_Ordering()

BOOLEAN rOrd_is_Totaldegree_Ordering ( const ring  r)

Definition at line 2013 of file ring.cc.

2014{
2015 // Hmm.... what about Syz orderings?
2016 return (rVar(r) > 1 &&
2017 ((rHasSimpleOrder(r) &&
2018 (rOrder_is_DegOrdering((rRingOrder_t)r->order[0]) ||
2019 rOrder_is_DegOrdering(( rRingOrder_t)r->order[1]))) ||
2020 (rHasSimpleOrderAA(r) &&
2021 (rOrder_is_DegOrdering((rRingOrder_t)r->order[1]) ||
2022 ((r->order[1]!=0) &&
2023 rOrder_is_DegOrdering((rRingOrder_t)r->order[2]))))));
2024}
BOOLEAN rOrder_is_DegOrdering(const rRingOrder_t order)
Definition ring.cc:1928
BOOLEAN rHasSimpleOrderAA(ring r)
Definition ring.cc:1962

◆ rOrd_SetCompRequiresSetm()

BOOLEAN rOrd_SetCompRequiresSetm ( const ring  r)

return TRUE if p_SetComp requires p_Setm

Definition at line 1993 of file ring.cc.

1994{
1995 if (r->typ != NULL)
1996 {
1997 int pos;
1998 for (pos=0;pos<r->OrdSize;pos++)
1999 {
2000 sro_ord* o=&(r->typ[pos]);
2001 if ( (o->ord_typ == ro_syzcomp)
2002 || (o->ord_typ == ro_syz)
2003 || (o->ord_typ == ro_is)
2004 || (o->ord_typ == ro_am)
2005 || (o->ord_typ == ro_isTemp))
2006 return TRUE;
2007 }
2008 }
2009 return FALSE;
2010}
ro_typ ord_typ
Definition ring.h:220

◆ rOrderName()

rRingOrder_t rOrderName ( char ordername)

Definition at line 507 of file ring.cc.

508{
509 int order=ringorder_unspec;
510 while (order!= 0)
511 {
512 if (strcmp(ordername,rSimpleOrdStr(order))==0)
513 break;
514 order--;
515 }
516 if (order==0) Werror("wrong ring order `%s`",ordername);
518 return (rRingOrder_t)order;
519}

◆ rOrdStr()

char * rOrdStr ( ring  r)

Definition at line 521 of file ring.cc.

522{
523 if ((r==NULL)||(r->order==NULL)) return omStrDup("");
524 int nblocks,l,i;
525
526 for (nblocks=0; r->order[nblocks]; nblocks++);
527 nblocks--;
528
529 StringSetS("");
530 for (l=0; ; l++)
531 {
532 StringAppendS((char *)rSimpleOrdStr(r->order[l]));
533 if (r->order[l] == ringorder_s)
534 {
535 StringAppend("(%d)",r->block0[l]);
536 }
537 else if (
538 (r->order[l] != ringorder_c)
539 && (r->order[l] != ringorder_C)
540 && (r->order[l] != ringorder_s)
541 && (r->order[l] != ringorder_S)
542 && (r->order[l] != ringorder_IS)
543 )
544 {
545 if (r->wvhdl[l]!=NULL)
546 {
547 #ifndef SING_NDEBUG
548 if((r->order[l] != ringorder_wp)
549 &&(r->order[l] != ringorder_Wp)
550 &&(r->order[l] != ringorder_ws)
551 &&(r->order[l] != ringorder_Ws)
552 &&(r->order[l] != ringorder_a)
553 &&(r->order[l] != ringorder_a64)
554 &&(r->order[l] != ringorder_am)
555 &&(r->order[l] != ringorder_M))
556 {
557 Warn("should not have wvhdl entry at pos. %d",l);
558 StringAppend("(%d)",r->block1[l]-r->block0[l]+1);
559 }
560 else
561 #endif
562 {
563 StringAppendS("(");
564 for (int j= 0;
565 j<(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1);
566 j+=i+1)
567 {
568 char c=',';
569 if(r->order[l]==ringorder_a64)
570 {
571 int64 * w=(int64 *)r->wvhdl[l];
572 for (i = 0; i<r->block1[l]-r->block0[l]; i++)
573 {
574 StringAppend("%lld," ,w[i]);
575 }
576 StringAppend("%lld)" ,w[i]);
577 break;
578 }
579 else
580 {
581 for (i = 0; i<r->block1[l]-r->block0[l]; i++)
582 {
583 StringAppend("%d," ,r->wvhdl[l][i+j]);
584 }
585 }
586 if (r->order[l]!=ringorder_M)
587 {
588 StringAppend("%d)" ,r->wvhdl[l][i+j]);
589 break;
590 }
591 if (j+i+1==(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1))
592 c=')';
593 StringAppend("%d%c" ,r->wvhdl[l][i+j],c);
594 }
595 }
596 }
597 else
598 StringAppend("(%d)",r->block1[l]-r->block0[l]+1);
599 }
600 else if (r->order[l] == ringorder_IS)
601 {
602 assume( r->block0[l] == r->block1[l] );
603 const int s = r->block0[l];
604 assume( (-2 < s) && (s < 2) );
605
606 StringAppend("(%d)", s);
607 }
608
609 if (l==nblocks)
610 {
611 if (r->wanted_maxExp!=0)
612 {
613 long mm=r->wanted_maxExp;
615 StringAppend(",L(%ld)",mm);
616 }
617 return StringEndS();
618 }
619 StringAppendS(",");
620 }
621}
#define StringAppend
Definition emacs.cc:79
const int MAX_INT_VAL
Definition mylimits.h:12
void StringSetS(const char *st)
Definition reporter.cc:128
void StringAppendS(const char *st)
Definition reporter.cc:107
char * StringEndS()
Definition reporter.cc:151

◆ rPar()

static int rPar ( const ring  r)
inlinestatic

(r->cf->P)

Definition at line 599 of file ring.h.

600{
601 assume(r != NULL);
602 const coeffs C = r->cf;
603 assume(C != NULL);
604
605 return n_NumberOfParameters(C);
606// if( nCoeff_is_Extension(C) )
607// {
608// const ring R = C->extRing;
609// assume( R != NULL );
610// return rVar( R );
611// }
612// else if (nCoeff_is_GF(C))
613// {
614// return 1;
615// }
616// else if (nCoeff_is_long_C(C))
617// {
618// return 1;
619// }
620// return 0;
621}
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition coeffs.h:771

◆ rParameter()

static char const ** rParameter ( const ring  r)
inlinestatic

(r->cf->parameter)

Definition at line 625 of file ring.h.

626{
627 assume(r != NULL);
628 const coeffs C = r->cf;
629 assume(C != NULL);
630
631 return n_ParameterNames(C);
632// if( nCoeff_is_Extension(C) ) // only alg / trans. exts...
633// {
634// const ring R = C->extRing;
635// assume( R != NULL );
636// return R->names;
637// }
638// else if (nCoeff_is_GF(C))
639// {
640// return &(C->m_nfParameter);
641// }
642// else if (nCoeff_is_long_C(C))
643// {
644// return &(C->complex_parameter);
645// }
646// return NULL;
647}
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition coeffs.h:775

◆ rParStr()

char * rParStr ( ring  r)

Definition at line 649 of file ring.cc.

650{
651 if ((r==NULL)||(rParameter(r)==NULL)) return omStrDup("");
652
653 char const * const * const params = rParameter(r);
654
655 int i;
656 int l=2;
657
658 for (i=0; i<rPar(r); i++)
659 {
660 l+=strlen(params[i])+1;
661 }
662 char *s=(char *)omAlloc((long)l);
663 s[0]='\0';
664 for (i=0; i<rPar(r)-1; i++)
665 {
666 strcat(s, params[i]);
667 strcat(s,",");
668 }
669 strcat(s, params[i]);
670 return s;
671}
static char const ** rParameter(const ring r)
(r->cf->parameter)
Definition ring.h:625

◆ rPlusVar()

ring rPlusVar ( const ring  r,
char v,
int  left 
)

K[x],"y" -> K[x,y] resp. K[y,x].

Definition at line 5855 of file ring.cc.

5856{
5857 if (r->order[2]!=0)
5858 {
5859 WerrorS("only for rings with an ordering of one block");
5860 return NULL;
5861 }
5862 int p;
5863 if((r->order[0]==ringorder_C)
5864 ||(r->order[0]==ringorder_c))
5865 p=1;
5866 else
5867 p=0;
5868 if((r->order[p]!=ringorder_dp)
5869 && (r->order[p]!=ringorder_Dp)
5870 && (r->order[p]!=ringorder_lp)
5871 && (r->order[p]!=ringorder_rp)
5872 && (r->order[p]!=ringorder_ds)
5873 && (r->order[p]!=ringorder_Ds)
5874 && (r->order[p]!=ringorder_ls))
5875 {
5876 WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5877 return NULL;
5878 }
5879 for(int i=r->N-1;i>=0;i--)
5880 {
5881 if (strcmp(r->names[i],v)==0)
5882 {
5883 Werror("duplicate variable name >>%s<<",v);
5884 return NULL;
5885 }
5886 }
5887 ring R=rCopy0(r);
5888 char **names;
5889 #ifdef HAVE_SHIFTBBA
5890 if (rIsLPRing(r))
5891 {
5892 R->isLPring=r->isLPring+1;
5893 R->N=((r->N)/r->isLPring)+r->N;
5894 names=(char**)omAlloc(R->N*sizeof(char_ptr));
5895 if (left)
5896 {
5897 for(int b=0;b<((r->N)/r->isLPring);b++)
5898 {
5899 names[b*R->isLPring]=omStrDup(v);
5900 for(int i=R->isLPring-1;i>0;i--)
5901 names[i+b*R->isLPring]=R->names[i-1+b*r->isLPring];
5902 }
5903 }
5904 else
5905 {
5906 for(int b=0;b<((r->N)/r->isLPring);b++)
5907 {
5908 names[(b+1)*R->isLPring-1]=omStrDup(v);
5909 for(int i=R->isLPring-2;i>=0;i--)
5910 names[i+b*R->isLPring]=R->names[i+b*r->isLPring];
5911 }
5912 }
5913 }
5914 else
5915 #endif
5916 {
5917 R->N++;
5918 names=(char**)omAlloc(R->N*sizeof(char_ptr));
5919 if (left)
5920 {
5921 names[0]=omStrDup(v);
5922 for(int i=R->N-1;i>0;i--) names[i]=R->names[i-1];
5923 }
5924 else
5925 {
5926 names[R->N-1]=omStrDup(v);
5927 for(int i=R->N-2;i>=0;i--) names[i]=R->names[i];
5928 }
5929 }
5930 omFreeSize(R->names,r->N*sizeof(char_ptr));
5931 R->names=names;
5932 R->block1[p]=R->N;
5933 rComplete(R);
5934 return R;
5935}
CanonicalForm b
Definition cfModGcd.cc:4103

◆ rRing_has_CompLastBlock()

BOOLEAN rRing_has_CompLastBlock ( const ring  r)

Definition at line 5246 of file ring.cc.

5247{
5248 assume(r != NULL);
5249 int lb = rBlocks(r) - 2;
5250 return (r->order[lb] == ringorder_c || r->order[lb] == ringorder_C);
5251}

◆ rRing_ord_pure_dp()

BOOLEAN rRing_ord_pure_dp ( const ring  r)

Definition at line 5253 of file ring.cc.

5254{
5255 if ((r->order[0]==ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5256 return TRUE;
5257 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5258 && ((r->order[1]==ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5259 return TRUE;
5260 return FALSE;
5261}

◆ rRing_ord_pure_Dp()

BOOLEAN rRing_ord_pure_Dp ( const ring  r)

Definition at line 5263 of file ring.cc.

5264{
5265 if ((r->order[0]==ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5266 return TRUE;
5267 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5268 && ((r->order[1]==ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5269 return TRUE;
5270 return FALSE;
5271}

◆ rRing_ord_pure_lp()

BOOLEAN rRing_ord_pure_lp ( const ring  r)

Definition at line 5273 of file ring.cc.

5274{
5275 if ((r->order[0]==ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5276 return TRUE;
5277 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5278 && ((r->order[1]==ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5279 return TRUE;
5280 return FALSE;
5281}

◆ rRingVar()

static char * rRingVar ( short  i,
const ring  r 
)
inlinestatic

Definition at line 577 of file ring.h.

578{
579 assume(r != NULL); assume(r->cf != NULL); return r->names[i];
580}

◆ rSamePolyRep()

BOOLEAN rSamePolyRep ( ring  r1,
ring  r2 
)

returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analogue to rEqual but not so strict

Definition at line 1799 of file ring.cc.

1800{
1801 int i, j;
1802
1803 if (r1 == r2) return TRUE;
1804
1805 if (r1 == NULL || r2 == NULL) return FALSE;
1806
1807 if ((r1->cf != r2->cf)
1808 || (rVar(r1) != rVar(r2))
1809 || (r1->OrdSgn != r2->OrdSgn))
1810 return FALSE;
1811
1812 i=0;
1813 while (r1->order[i] != 0)
1814 {
1815 if (r2->order[i] == 0) return FALSE;
1816 if ((r1->order[i] != r2->order[i])
1817 || (r1->block0[i] != r2->block0[i])
1818 || (r1->block1[i] != r2->block1[i]))
1819 return FALSE;
1820 if (r1->wvhdl[i] != NULL)
1821 {
1822 if (r2->wvhdl[i] == NULL)
1823 return FALSE;
1824 for (j=0; j<r1->block1[i]-r1->block0[i]+1; j++)
1825 if (r2->wvhdl[i][j] != r1->wvhdl[i][j])
1826 return FALSE;
1827 }
1828 else if (r2->wvhdl[i] != NULL) return FALSE;
1829 i++;
1830 }
1831 if (r2->order[i] != 0) return FALSE;
1832
1833 // we do not check variable names
1834 // we do not check minpoly/minideal
1835 // we do not check qideal
1836
1837 return TRUE;
1838}

◆ rSetISReference()

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, we will DO a copy! We will use it AS IS! returns true is everything was allright!

Definition at line 5093 of file ring.cc.

5094{
5095 // Put the reference set F into the ring -ordering -recor
5096
5097 if (r->typ==NULL)
5098 {
5099 dReportError("Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5100 return FALSE;
5101 }
5102
5103
5104 int pos = rGetISPos(p, r);
5105
5106 if( pos == -1 )
5107 {
5108 dReportError("Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5109 return FALSE;
5110 }
5111
5112#if MYTEST
5113 if( i != r->typ[pos].data.is.limit )
5114 Print("Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
5115#endif
5116
5117 const ideal FF = idrHeadR(F, r, r); // id_Copy(F, r); // ???
5118
5119
5120 if( r->typ[pos].data.is.F != NULL)
5121 {
5122#if MYTEST
5123 PrintS("Deleting old reference set F... \n"); // idShow(r->typ[pos].data.is.F, r); PrintLn();
5124#endif
5125 id_Delete(&r->typ[pos].data.is.F, r);
5126 r->typ[pos].data.is.F = NULL;
5127 }
5128
5129 assume(r->typ[pos].data.is.F == NULL);
5130
5131 r->typ[pos].data.is.F = FF; // F is owened by ring now! TODO: delete at the end!
5132
5133 r->typ[pos].data.is.limit = i; // First induced component
5134
5135#if MYTEST
5136 PrintS("New reference set FF : \n"); idShow(FF, r, r, 1); PrintLn();
5137#endif
5138
5139 return TRUE;
5140}
int rGetISPos(const int p, const ring r)
Finds p^th IS ordering, and returns its position in r->typ[] returns -1 if something went wrong!...
Definition ring.cc:5061
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)

◆ rSetSyzComp()

void rSetSyzComp ( int  k,
const ring  r 
)

Definition at line 5147 of file ring.cc.

5148{
5149 if(k < 0)
5150 {
5151 dReportError("rSetSyzComp with negative limit!");
5152 return;
5153 }
5154
5155 assume( k >= 0 );
5156 if (TEST_OPT_PROT) Print("{%d}", k);
5157 if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz))
5158 {
5159 r->block0[0]=r->block1[0] = k;
5160 if( k == r->typ[0].data.syz.limit )
5161 return; // nothing to do
5162
5163 int i;
5164 if (r->typ[0].data.syz.limit == 0)
5165 {
5166 r->typ[0].data.syz.syz_index = (int*) omAlloc0((k+1)*sizeof(int));
5167 r->typ[0].data.syz.syz_index[0] = 0;
5168 r->typ[0].data.syz.curr_index = 1;
5169 }
5170 else
5171 {
5172 r->typ[0].data.syz.syz_index = (int*)
5173 omReallocSize(r->typ[0].data.syz.syz_index,
5174 (r->typ[0].data.syz.limit+1)*sizeof(int),
5175 (k+1)*sizeof(int));
5176 }
5177 for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
5178 {
5179 r->typ[0].data.syz.syz_index[i] =
5180 r->typ[0].data.syz.curr_index;
5181 }
5182 if(k < r->typ[0].data.syz.limit) // ?
5183 {
5184#ifndef SING_NDEBUG
5185 Warn("rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
5186#endif
5187 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[k];
5188 }
5189
5190
5191 r->typ[0].data.syz.limit = k;
5192 r->typ[0].data.syz.curr_index++;
5193 }
5194 else if(
5195 (r->typ!=NULL) &&
5196 (r->typ[0].ord_typ==ro_isTemp)
5197 )
5198 {
5199// (r->typ[currRing->typ[0].data.isTemp.suffixpos].data.is.limit == k)
5200#ifndef SING_NDEBUG
5201 Warn("rSetSyzComp(%d) in an IS ring! Be careful!", k);
5202#endif
5203 }
5204 else if (r->order[0]==ringorder_s)
5205 {
5206 r->block0[0] = r->block1[0] = k;
5207 }
5208 else if (r->order[0]!=ringorder_c)
5209 {
5210 dReportError("syzcomp in incompatible ring");
5211 }
5212#ifdef PDEBUG
5214 pDBsyzComp=k;
5215#endif
5216}
#define EXTERN_VAR
Definition globaldefs.h:6
#define TEST_OPT_PROT
Definition options.h:103
VAR int pDBsyzComp
Definition ring.cc:5143

◆ rSetWeightVec()

void rSetWeightVec ( ring  r,
int64 wv 
)

Definition at line 5293 of file ring.cc.

5294{
5295 assume(r!=NULL);
5296 assume(r->OrdSize>0);
5297 assume(r->typ[0].ord_typ==ro_wp64);
5298 memcpy(r->typ[0].data.wp64.weights64,wv,r->N*sizeof(int64));
5299}

◆ rShortOut()

static BOOLEAN rShortOut ( const ring  r)
inlinestatic

Definition at line 581 of file ring.h.

582{
583 assume(r != NULL); return (r->ShortOut);
584}

◆ rSimpleOrdStr()

const char * rSimpleOrdStr ( int  ord)

Definition at line 77 of file ring.cc.

78{
79 return ringorder_name[ord];
80}
static const char *const ringorder_name[]
Definition ring.cc:47

◆ rString()

char * rString ( ring  r)

Definition at line 673 of file ring.cc.

674{
675 if ((r!=NULL)&&(r->cf!=NULL))
676 {
677 char *ch=rCharStr(r);
678 char *var=rVarStr(r);
679 char *ord=rOrdStr(r);
680 char *res=(char *)omAlloc(strlen(ch)+strlen(var)+strlen(ord)+9);
681 sprintf(res,"(%s),(%s),(%s)",ch,var,ord);
682 omFree((ADDRESS)ch);
683 omFree((ADDRESS)var);
684 omFree((ADDRESS)ord);
685 return res;
686 }
687 else
688 return omStrDup("undefined");
689}
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition ring.cc:647
char * rOrdStr(ring r)
Definition ring.cc:521
char * rVarStr(ring r)
Definition ring.cc:623

◆ rSum()

int rSum ( ring  r1,
ring  r2,
ring sum 
)

Definition at line 1402 of file ring.cc.

1403{
1404 if ((r1==NULL)||(r2==NULL)
1405 ||(r1->cf==NULL)||(r2->cf==NULL))
1406 return -1;
1407 if (r1==r2)
1408 {
1409 sum=r1;
1410 rIncRefCnt(r1);
1411 return 0;
1412 }
1413 return rSumInternal(r1,r2,sum,TRUE,FALSE);
1414}
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,...
Definition ring.cc:749
static ring rIncRefCnt(ring r)
Definition ring.h:840

◆ rSumInternal()

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

Definition at line 749 of file ring.cc.

750{
751
753 memset(&tmpR,0,sizeof(tmpR));
754 /* check coeff. field =====================================================*/
755
756 if (r1->cf==r2->cf)
757 {
758 tmpR.cf=nCopyCoeff(r1->cf);
759 }
760 else /* different type */
761 {
762 if (getCoeffType(r1->cf)==n_Zp)
763 {
764 if (getCoeffType(r2->cf)==n_Q)
765 {
766 tmpR.cf=nCopyCoeff(r1->cf);
767 }
768 else if (nCoeff_is_Extension(r2->cf) && rChar(r2) == rChar(r1))
769 {
770 /*AlgExtInfo extParam;
771 extParam.r = r2->cf->extRing;
772 extParam.i = r2->cf->extRing->qideal;*/
773 tmpR.cf=nCopyCoeff(r2->cf);
774 }
775 else
776 {
777 WerrorS("Z/p+...");
778 return -1;
779 }
780 }
781 else if ((getCoeffType(r1->cf)==n_Zn)||(getCoeffType(r1->cf)==n_Znm))
782 {
783 if (getCoeffType(r2->cf)==n_Q)
784 {
785 tmpR.cf=nCopyCoeff(r1->cf);
786 }
787 else if (nCoeff_is_Extension(r2->cf)
788 && (mpz_cmp(r1->cf->modNumber,r2->cf->extRing->cf->modNumber)==0))
789 { // covers transext.cc and algext.cc
790 tmpR.cf=nCopyCoeff(r2->cf);
791 }
792 else
793 {
794 WerrorS("Z/n+...");
795 return -1;
796 }
797 }
798 else if (getCoeffType(r1->cf)==n_R)
799 {
800 WerrorS("R+..");
801 return -1;
802 }
803 else if (getCoeffType(r1->cf)==n_Q)
804 {
805 if (getCoeffType(r2->cf)==n_Zp)
806 {
807 tmpR.cf=nCopyCoeff(r2->cf);
808 }
809 else if (nCoeff_is_Extension(r2->cf))
810 {
811 tmpR.cf=nCopyCoeff(r2->cf);
812 }
813 else
814 {
815 WerrorS("Q+...");
816 return -1;
817 }
818 }
819 else if (nCoeff_is_Extension(r1->cf))
820 {
821 if (r1->cf->extRing->cf==r2->cf)
822 {
823 tmpR.cf=nCopyCoeff(r1->cf);
824 }
825 else if (getCoeffType(r1->cf->extRing->cf)==n_Zp && getCoeffType(r2->cf)==n_Q) //r2->cf == n_Zp should have been handled above
826 {
827 tmpR.cf=nCopyCoeff(r1->cf);
828 }
829 else
830 {
831 WerrorS ("coeff sum of two extension fields not implemented");
832 return -1;
833 }
834 }
835 else
836 {
837 WerrorS("coeff sum not yet implemented");
838 return -1;
839 }
840 }
841 /* variable names ========================================================*/
842 int i,j,k;
843 int l=r1->N+r2->N;
844 char **names=(char **)omAlloc0(l*sizeof(char *));
845 k=0;
846
847 // collect all varnames from r1, except those which are parameters
848 // of r2, or those which are the empty string
849 for (i=0;i<r1->N;i++)
850 {
851 BOOLEAN b=TRUE;
852
853 if (*(r1->names[i]) == '\0')
854 b = FALSE;
855 else if ((rParameter(r2)!=NULL) && (strlen(r1->names[i])==1))
856 {
857 if (vartest)
858 {
859 for(j=0;j<rPar(r2);j++)
860 {
861 if (strcmp(r1->names[i],rParameter(r2)[j])==0)
862 {
863 b=FALSE;
864 break;
865 }
866 }
867 }
868 }
869
870 if (b)
871 {
872 //Print("name : %d: %s\n",k,r1->names[i]);
873 names[k]=omStrDup(r1->names[i]);
874 k++;
875 }
876 //else
877 // Print("no name (par1) %s\n",r1->names[i]);
878 }
879 // Add variables from r2, except those which are parameters of r1
880 // those which are empty strings, and those which equal a var of r1
881 for(i=0;i<r2->N;i++)
882 {
883 BOOLEAN b=TRUE;
884
885 if (*(r2->names[i]) == '\0')
886 b = FALSE;
887 else if ((rParameter(r1)!=NULL) && (strlen(r2->names[i])==1))
888 {
889 if (vartest)
890 {
891 for(j=0;j<rPar(r1);j++)
892 {
893 if (strcmp(r2->names[i],rParameter(r1)[j])==0)
894 {
895 b=FALSE;
896 break;
897 }
898 }
899 }
900 }
901
902 if (b)
903 {
904 if (vartest)
905 {
906 for(j=0;j<r1->N;j++)
907 {
908 if (strcmp(r1->names[j],r2->names[i])==0)
909 {
910 b=FALSE;
911 break;
912 }
913 }
914 }
915 if (b)
916 {
917 //Print("name : %d : %s\n",k,r2->names[i]);
918 names[k]=omStrDup(r2->names[i]);
919 k++;
920 }
921 //else
922 // Print("no name (var): %s\n",r2->names[i]);
923 }
924 //else
925 // Print("no name (par): %s\n",r2->names[i]);
926 }
927 // check whether we found any vars at all
928 if (k == 0)
929 {
930 names[k]=omStrDup("");
931 k=1;
932 }
933 tmpR.N=k;
934 tmpR.names=names;
935 /* ordering *======================================================== */
936 tmpR.OrdSgn=0;
937 if ((dp_dp==2)
938 && (r1->OrdSgn==1)
939 && (r2->OrdSgn==1)
942#endif
943 )
944 {
945 tmpR.order=(rRingOrder_t*)omAlloc0(4*sizeof(rRingOrder_t));
946 tmpR.block0=(int*)omAlloc0(4*sizeof(int));
947 tmpR.block1=(int*)omAlloc0(4*sizeof(int));
948 tmpR.wvhdl=(int**) omAlloc0(4*sizeof(int**));
949 // ----
950 tmpR.block0[0] = 1;
951 tmpR.block1[0] = rVar(r1)+rVar(r2);
952 tmpR.order[0] = ringorder_aa;
953 tmpR.wvhdl[0]=(int*)omAlloc0((rVar(r1)+rVar(r2) + 1)*sizeof(int));
954 for(int i=0;i<rVar(r1);i++) tmpR.wvhdl[0][i]=1;
955 // ----
956 tmpR.block0[1] = 1;
957 tmpR.block1[1] = rVar(r1)+rVar(r2);
958 tmpR.order[1] = ringorder_dp;
959 // ----
960 tmpR.order[2] = ringorder_C;
961 }
962 else if (dp_dp
965#endif
966 )
967 {
968 tmpR.order=(rRingOrder_t*)omAlloc(4*sizeof(rRingOrder_t));
969 tmpR.block0=(int*)omAlloc0(4*sizeof(int));
970 tmpR.block1=(int*)omAlloc0(4*sizeof(int));
971 tmpR.wvhdl=(int**)omAlloc0(4*sizeof(int *));
972 tmpR.order[0]=ringorder_dp;
973 tmpR.block0[0]=1;
974 tmpR.block1[0]=rVar(r1);
975 if (r2->OrdSgn==1)
976 {
977 if ((r2->block0[0]==1)
978 && (r2->block1[0]==rVar(r2))
979 && ((r2->order[0]==ringorder_wp)
980 || (r2->order[0]==ringorder_Wp)
981 || (r2->order[0]==ringorder_Dp))
982 )
983 {
984 tmpR.order[1]=r2->order[0];
985 if (r2->wvhdl[0]!=NULL)
986 #ifdef HAVE_OMALLOC
987 tmpR.wvhdl[1]=(int *)omMemDup(r2->wvhdl[0]);
988 #else
989 {
990 int l=r2->block1[0]-r2->block0[0]+1;
991 if (r2->order[0]==ringorder_a64) l*=2;
992 else if (r2->order[0]==ringorder_M) l=l*l;
993 else if (r2->order[0]==ringorder_am)
994 {
995 l+=r2->wvhdl[1][r2->block1[0]-r2->block0[0]+1]+1;
996 }
997 tmpR.wvhdl[1]=(int*)omalloc(l*sizeof(int));
998 memcpy(tmpR.wvhdl[1],r2->wvhdl[0],l*sizeof(int));
999 }
1000 #endif
1001 }
1002 else
1003 tmpR.order[1]=ringorder_dp;
1004 }
1005 else
1006 {
1007 tmpR.order[1]=ringorder_ds;
1008 tmpR.OrdSgn=-1;
1009 }
1010 tmpR.block0[1]=rVar(r1)+1;
1011 tmpR.block1[1]=rVar(r1)+rVar(r2);
1012 tmpR.order[2]=ringorder_C;
1013 tmpR.order[3]=(rRingOrder_t)0;
1014 }
1015 else
1016 {
1017 if ((r1->order[0]==ringorder_unspec)
1018 && (r2->order[0]==ringorder_unspec))
1019 {
1020 tmpR.order=(rRingOrder_t*)omAlloc(3*sizeof(rRingOrder_t));
1021 tmpR.block0=(int*)omAlloc(3*sizeof(int));
1022 tmpR.block1=(int*)omAlloc(3*sizeof(int));
1023 tmpR.wvhdl=(int**)omAlloc0(3*sizeof(int *));
1024 tmpR.order[0]=ringorder_unspec;
1025 tmpR.order[1]=ringorder_C;
1026 tmpR.order[2]=(rRingOrder_t)0;
1027 tmpR.block0[0]=1;
1028 tmpR.block1[0]=tmpR.N;
1029 }
1030 else if (l==k) /* r3=r1+r2 */
1031 {
1032 int b;
1033 ring rb;
1034 if (r1->order[0]==ringorder_unspec)
1035 {
1036 /* extend order of r2 to r3 */
1037 b=rBlocks(r2);
1038 rb=r2;
1039 tmpR.OrdSgn=r2->OrdSgn;
1040 }
1041 else if (r2->order[0]==ringorder_unspec)
1042 {
1043 /* extend order of r1 to r3 */
1044 b=rBlocks(r1);
1045 rb=r1;
1046 tmpR.OrdSgn=r1->OrdSgn;
1047 }
1048 else
1049 {
1050 b=rBlocks(r1)+rBlocks(r2)-2; /* for only one order C, only one 0 */
1051 rb=NULL;
1052 }
1053 tmpR.order=(rRingOrder_t*)omAlloc0(b*sizeof(rRingOrder_t));
1054 tmpR.block0=(int*)omAlloc0(b*sizeof(int));
1055 tmpR.block1=(int*)omAlloc0(b*sizeof(int));
1056 tmpR.wvhdl=(int**)omAlloc0(b*sizeof(int *));
1057 /* weights not implemented yet ...*/
1058 if (rb!=NULL)
1059 {
1060 for (i=0;i<b;i++)
1061 {
1062 tmpR.order[i]=rb->order[i];
1063 tmpR.block0[i]=rb->block0[i];
1064 tmpR.block1[i]=rb->block1[i];
1065 if (rb->wvhdl[i]!=NULL)
1066 WarnS("rSum: weights not implemented");
1067 }
1068 tmpR.block0[0]=1;
1069 }
1070 else /* ring sum for complete rings */
1071 {
1072 for (i=0;r1->order[i]!=0;i++)
1073 {
1074 tmpR.order[i]=r1->order[i];
1075 tmpR.block0[i]=r1->block0[i];
1076 tmpR.block1[i]=r1->block1[i];
1077 if (r1->wvhdl[i]!=NULL)
1078 #ifdef HAVE_OMALLOC
1079 tmpR.wvhdl[i] = (int*) omMemDup(r1->wvhdl[i]);
1080 #else
1081 {
1082 int l=r1->block1[i]-r1->block0[i]+1;
1083 if (r1->order[i]==ringorder_a64) l*=2;
1084 else if (r1->order[i]==ringorder_M) l=l*l;
1085 else if (r1->order[i]==ringorder_am)
1086 {
1087 l+=r1->wvhdl[i][r1->block1[i]-r1->block0[i]+1]+1;
1088 }
1089 tmpR.wvhdl[i]=(int*)omalloc(l*sizeof(int));
1090 memcpy(tmpR.wvhdl[i],r1->wvhdl[i],l*sizeof(int));
1091 }
1092 #endif
1093 }
1094 j=i;
1095 i--;
1096 if ((r1->order[i]==ringorder_c)
1097 ||(r1->order[i]==ringorder_C))
1098 {
1099 j--;
1100 tmpR.order[b-2]=r1->order[i];
1101 }
1102 for (i=0;r2->order[i]!=0;i++)
1103 {
1104 if ((r2->order[i]!=ringorder_c)
1105 &&(r2->order[i]!=ringorder_C))
1106 {
1107 tmpR.order[j]=r2->order[i];
1108 tmpR.block0[j]=r2->block0[i]+rVar(r1);
1109 tmpR.block1[j]=r2->block1[i]+rVar(r1);
1110 if (r2->wvhdl[i]!=NULL)
1111 {
1112 #ifdef HAVE_OMALLOC
1113 tmpR.wvhdl[j] = (int*) omMemDup(r2->wvhdl[i]);
1114 #else
1115 {
1116 int l=r2->block1[i]-r2->block0[i]+1;
1117 if (r2->order[i]==ringorder_a64) l*=2;
1118 else if (r2->order[i]==ringorder_M) l=l*l;
1119 else if (r2->order[i]==ringorder_am)
1120 {
1121 l+=r2->wvhdl[i][r2->block1[i]-r2->block0[i]+1]+1;
1122 }
1123 tmpR.wvhdl[j]=(int*)omalloc(l*sizeof(int));
1124 memcpy(tmpR.wvhdl[j],r2->wvhdl[i],l*sizeof(int));
1125 }
1126 #endif
1127 }
1128 j++;
1129 }
1130 }
1131 if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
1132 tmpR.OrdSgn=-1;
1133 }
1134 }
1135 else if ((k==rVar(r1)) && (k==rVar(r2))) /* r1 and r2 are "quite"
1136 the same ring */
1137 /* copy r1, because we have the variables from r1 */
1138 {
1139 int b=rBlocks(r1);
1140
1141 tmpR.order=(rRingOrder_t*)omAlloc0(b*sizeof(rRingOrder_t));
1142 tmpR.block0=(int*)omAlloc0(b*sizeof(int));
1143 tmpR.block1=(int*)omAlloc0(b*sizeof(int));
1144 tmpR.wvhdl=(int**)omAlloc0(b*sizeof(int *));
1145 /* weights not implemented yet ...*/
1146 for (i=0;i<b;i++)
1147 {
1148 tmpR.order[i]=r1->order[i];
1149 tmpR.block0[i]=r1->block0[i];
1150 tmpR.block1[i]=r1->block1[i];
1151 if (r1->wvhdl[i]!=NULL)
1152 {
1153 #ifdef HAVE_OMALLOC
1154 tmpR.wvhdl[i] = (int*) omMemDup(r1->wvhdl[i]);
1155 #else
1156 {
1157 int l=r1->block1[i]-r1->block0[i]+1;
1158 if (r1->order[i]==ringorder_a64) l*=2;
1159 else if (r1->order[i]==ringorder_M) l=l*l;
1160 else if (r1->order[i]==ringorder_am)
1161 {
1162 l+=r1->wvhdl[i][r1->block1[i]-r1->block0[i]+1]+1;
1163 }
1164 tmpR.wvhdl[i]=(int*)omalloc(l*sizeof(int));
1165 memcpy(tmpR.wvhdl[i],r1->wvhdl[i],l*sizeof(int));
1166 }
1167 #endif
1168 }
1169 }
1170 tmpR.OrdSgn=r1->OrdSgn;
1171 }
1172 else
1173 {
1174 for(i=0;i<k;i++) omFree((ADDRESS)tmpR.names[i]);
1175 omFreeSize((ADDRESS)names,tmpR.N*sizeof(char *));
1176 Werror("variables must not overlap (# of vars: %d,%d -> %d)",rVar(r1),rVar(r2),k);
1177 return -1;
1178 }
1179 }
1180 tmpR.bitmask=si_max(r1->bitmask,r2->bitmask);
1182 memcpy(sum,&tmpR,sizeof(ip_sring));
1183 rComplete(sum);
1184
1185//#ifdef RDEBUG
1186// rDebugPrint(sum);
1187//#endif
1188
1189
1190
1191#ifdef HAVE_PLURAL
1192 if(1)
1193 {
1194// ring old_ring = currRing;
1195
1198
1199 if ( (R1_is_nc) || (R2_is_nc))
1200 {
1203
1204#if 0
1205#ifdef RDEBUG
1206 rWrite(R1);
1207 rDebugPrint(R1);
1208#endif
1209#endif
1211#if 0
1212#ifdef RDEBUG
1213 rWrite(R2);
1214 rDebugPrint(R2);
1215#endif
1216#endif
1217
1218// rChangeCurrRing(sum); // ?
1219
1220 // Projections from R_i into Sum:
1221 /* multiplication matrices business: */
1222 /* find permutations of vars and pars */
1223 int *perm1 = (int *)omAlloc0((rVar(R1)+1)*sizeof(int));
1224 int *par_perm1 = NULL;
1225 if (rPar(R1)!=0) par_perm1=(int *)omAlloc0((rPar(R1)+1)*sizeof(int));
1226
1227 int *perm2 = (int *)omAlloc0((rVar(R2)+1)*sizeof(int));
1228 int *par_perm2 = NULL;
1229 if (rPar(R2)!=0) par_perm2=(int *)omAlloc0((rPar(R2)+1)*sizeof(int));
1230
1231 maFindPerm(R1->names, rVar(R1), rParameter(R1), rPar(R1),
1232 sum->names, rVar(sum), rParameter(sum), rPar(sum),
1233 perm1, par_perm1, sum->cf->type);
1234
1235 maFindPerm(R2->names, rVar(R2), rParameter(R2), rPar(R2),
1236 sum->names, rVar(sum), rParameter(sum), rPar(sum),
1237 perm2, par_perm2, sum->cf->type);
1238
1239
1240 matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
1241 matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
1242
1243 // !!!! BUG? C1 and C2 might live in different baserings!!!
1244
1245 int l = rVar(R1) + rVar(R2);
1246
1247 matrix C = mpNew(l,l);
1248 matrix D = mpNew(l,l);
1249
1250 for (i = 1; i <= rVar(R1); i++)
1251 for (j= rVar(R1)+1; j <= l; j++)
1252 MATELEM(C,i,j) = p_One(sum); // in 'sum'
1253
1254 id_Test((ideal)C, sum);
1255
1256 nMapFunc nMap1 = n_SetMap(R1->cf,sum->cf); /* can change something global: not usable
1257 after the next nSetMap call :( */
1258 // Create blocked C and D matrices:
1259 for (i=1; i<= rVar(R1); i++)
1260 for (j=i+1; j<=rVar(R1); j++)
1261 {
1262 assume(MATELEM(C1,i,j) != NULL);
1263 MATELEM(C,i,j) = p_PermPoly(MATELEM(C1,i,j), perm1, R1, sum, nMap1, par_perm1, rPar(R1)); // need ADD + CMP ops.
1264
1265 if (MATELEM(D1,i,j) != NULL)
1267 }
1268
1269 id_Test((ideal)C, sum);
1270 id_Test((ideal)D, sum);
1271
1272
1273 nMapFunc nMap2 = n_SetMap(R2->cf,sum->cf); /* can change something global: not usable
1274 after the next nSetMap call :( */
1275 for (i=1; i<= rVar(R2); i++)
1276 for (j=i+1; j<=rVar(R2); j++)
1277 {
1278 assume(MATELEM(C2,i,j) != NULL);
1280
1281 if (MATELEM(D2,i,j) != NULL)
1283 }
1284
1285 id_Test((ideal)C, sum);
1286 id_Test((ideal)D, sum);
1287
1288 // Now sum is non-commutative with blocked structure constants!
1289 if (nc_CallPlural(C, D, NULL, NULL, sum, false, false, true, sum))
1290 WarnS("Error initializing non-commutative multiplication!");
1291
1292 /* delete R1, R2*/
1293
1294#if 0
1295#ifdef RDEBUG
1296 rWrite(sum);
1298
1299 Print("\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
1300
1301#endif
1302#endif
1303
1304
1305 rDelete(R1);
1306 rDelete(R2);
1307
1308 /* delete perm arrays */
1309 if (perm1!=NULL) omFree((ADDRESS)perm1);
1310 if (perm2!=NULL) omFree((ADDRESS)perm2);
1313
1314// rChangeCurrRing(old_ring);
1315 }
1316
1317 }
1318#endif
1319
1320 ideal Q=NULL;
1321 ideal Q1=NULL, Q2=NULL;
1322 if (r1->qideal!=NULL)
1323 {
1324// rChangeCurrRing(sum);
1325// if (r2->qideal!=NULL)
1326// {
1327// WerrorS("todo: qring+qring");
1328// return -1;
1329// }
1330// else
1331// {}
1332 /* these were defined in the Plural Part above... */
1333 int *perm1 = (int *)omAlloc0((rVar(r1)+1)*sizeof(int));
1334 int *par_perm1 = NULL;
1335 if (rPar(r1)!=0) par_perm1=(int *)omAlloc0((rPar(r1)+1)*sizeof(int));
1336 maFindPerm(r1->names, rVar(r1), rParameter(r1), rPar(r1),
1337 sum->names, rVar(sum), rParameter(sum), rPar(sum),
1338 perm1, par_perm1, sum->cf->type);
1339 nMapFunc nMap1 = n_SetMap(r1->cf,sum->cf);
1340 Q1 = idInit(IDELEMS(r1->qideal),1);
1341
1342 for (int for_i=0;for_i<IDELEMS(r1->qideal);for_i++)
1343 Q1->m[for_i] = p_PermPoly(
1344 r1->qideal->m[for_i], perm1,
1345 r1, sum,
1346 nMap1,
1347 par_perm1, rPar(r1));
1348
1350 }
1351
1352 if (r2->qideal!=NULL)
1353 {
1354 //if (currRing!=sum)
1355 // rChangeCurrRing(sum);
1356 int *perm2 = (int *)omAlloc0((rVar(r2)+1)*sizeof(int));
1357 int *par_perm2 = NULL;
1358 if (rPar(r2)!=0) par_perm2=(int *)omAlloc0((rPar(r2)+1)*sizeof(int));
1359 maFindPerm(r2->names, rVar(r2), rParameter(r2), rPar(r2),
1360 sum->names, rVar(sum), rParameter(sum), rPar(sum),
1361 perm2, par_perm2, sum->cf->type);
1362 nMapFunc nMap2 = n_SetMap(r2->cf,sum->cf);
1363 Q2 = idInit(IDELEMS(r2->qideal),1);
1364
1365 for (int for_i=0;for_i<IDELEMS(r2->qideal);for_i++)
1366 Q2->m[for_i] = p_PermPoly(
1367 r2->qideal->m[for_i], perm2,
1368 r2, sum,
1369 nMap2,
1370 par_perm2, rPar(r2));
1371
1373 }
1374 if (Q1!=NULL)
1375 {
1376 if ( Q2!=NULL)
1377 Q = id_SimpleAdd(Q1,Q2,sum);
1378 else
1379 Q=id_Copy(Q1,sum);
1380 }
1381 else
1382 {
1383 if ( Q2!=NULL)
1384 Q = id_Copy(Q2,sum);
1385 else
1386 Q=NULL;
1387 }
1388 sum->qideal = Q;
1389
1390#ifdef HAVE_PLURAL
1391 if( rIsPluralRing(sum) )
1393#endif
1394 return 1;
1395}
static int si_max(const int a, const int b)
Definition auxiliary.h:124
@ n_R
single prescision (6,6) real numbers
Definition coeffs.h:31
@ n_Znm
only used if HAVE_RINGS is defined
Definition coeffs.h:45
@ n_Zn
only used if HAVE_RINGS is defined
Definition coeffs.h:44
void maFindPerm(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch)
Definition maps.cc:163
#define omAllocBin(bin)
poly p_One(const ring r)
Definition p_polys.cc:1313
int rChar(ring r)
Definition ring.cc:713
ring nc_rCreateNCcomm_rCopy(ring r)
Definition ring.cc:719
ideal idInit(int idsize, int rank)
initialise an ideal / module
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
#define Q
Definition sirandom.c:26

◆ rTypeOfMatrixOrder()

int rTypeOfMatrixOrder ( const intvec order)

Definition at line 185 of file ring.cc.

186{
187 int i=0,j,typ=1;
188 int sz = (int)sqrt((double)(order->length()-2));
189 if ((sz*sz)!=(order->length()-2))
190 {
191 WerrorS("Matrix order is not a square matrix");
192 typ=0;
193 }
194 while ((i<sz) && (typ==1))
195 {
196 j=0;
197 while ((j<sz) && ((*order)[j*sz+i+2]==0)) j++;
198 if (j>=sz)
199 {
200 typ = 0;
201 WerrorS("Matrix order not complete");
202 }
203 else if ((*order)[j*sz+i+2]<0)
204 typ = -1;
205 else
206 i++;
207 }
208 return typ;
209}
gmp_float sqrt(const gmp_float &a)

◆ rUnComplete()

void rUnComplete ( ring  r)

Definition at line 3974 of file ring.cc.

3975{
3976 if (r == NULL) return;
3977 if (r->VarOffset != NULL)
3978 {
3979 if (r->OrdSize!=0 && r->typ != NULL)
3980 {
3981 for(int i = 0; i < r->OrdSize; i++)
3982 if( r->typ[i].ord_typ == ro_is) // Search for suffixes! (prefix have the same VarOffset)
3983 {
3984 id_Delete(&r->typ[i].data.is.F, r);
3985
3986 if( r->typ[i].data.is.pVarOffset != NULL )
3987 {
3988 omFreeSize((ADDRESS)r->typ[i].data.is.pVarOffset, (r->N +1)*sizeof(int));
3989 }
3990 }
3991 else if (r->typ[i].ord_typ == ro_syz)
3992 {
3993 if(r->typ[i].data.syz.limit > 0)
3994 omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*sizeof(int));
3995 }
3996 else if (r->typ[i].ord_typ == ro_syzcomp)
3997 {
3998 assume( r->typ[i].data.syzcomp.ShiftedComponents == NULL );
3999 assume( r->typ[i].data.syzcomp.Components == NULL );
4000// WarnS( "rUnComplete : ord_typ == ro_syzcomp was unhandled!!! Possibly memory leak!!!" );
4001#ifndef SING_NDEBUG
4002// assume(0);
4003#endif
4004 }
4005
4006 omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord)); r->typ = NULL;
4007 }
4008
4009 if (r->PolyBin != NULL)
4010 omUnGetSpecBin(&(r->PolyBin));
4011
4012 omFreeSize((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
4013 r->VarOffset=NULL;
4014
4015 if (r->ordsgn != NULL && r->CmpL_Size != 0)
4016 {
4017 omFreeSize((ADDRESS)r->ordsgn,r->ExpL_Size*sizeof(long));
4018 r->ordsgn=NULL;
4019 }
4020 if (r->p_Procs != NULL)
4021 {
4022 omFreeSize(r->p_Procs, sizeof(p_Procs_s));
4023 r->p_Procs=NULL;
4024 }
4025 omfreeSize(r->VarL_Offset, r->VarL_Size*sizeof(int));
4026 r->VarL_Offset=NULL;
4027 }
4028 if (r->NegWeightL_Offset!=NULL)
4029 {
4030 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*sizeof(int));
4031 r->NegWeightL_Offset=NULL;
4032 }
4033}
#define omfreeSize(addr, size)
#define omUnGetSpecBin(bin_ptr)
Definition omBin.h:14

◆ rVar()

static short rVar ( const ring  r)
inlinestatic

#define rVar(r) (r->N)

Definition at line 592 of file ring.h.

593{
594 assume(r != NULL);
595 return r->N;
596}

◆ rVarStr()

char * rVarStr ( ring  r)

Definition at line 623 of file ring.cc.

624{
625 if ((r==NULL)||(r->names==NULL)) return omStrDup("");
626 int i;
627 int l=2;
628 char *s;
629
630 for (i=0; i<r->N; i++)
631 {
632 l+=strlen(r->names[i])+1;
633 }
634 s=(char *)omAlloc((long)l);
635 s[0]='\0';
636 for (i=0; i<r->N-1; i++)
637 {
638 strcat(s,r->names[i]);
639 strcat(s,",");
640 }
641 strcat(s,r->names[i]);
642 return s;
643}

◆ rWrite()

void rWrite ( ring  r,
BOOLEAN  details = FALSE 
)

Definition at line 226 of file ring.cc.

227{
228 if ((r==NULL)||(r->order==NULL))
229 return; /*to avoid printing after errors....*/
230
231 assume(r != NULL);
232 const coeffs C = r->cf;
233 assume(C != NULL);
234
235 int nblocks=rBlocks(r);
236
237 // omCheckAddrSize(r,sizeof(ip_sring));
238 omCheckAddrSize(r->order,nblocks*sizeof(int));
239 omCheckAddrSize(r->block0,nblocks*sizeof(int));
240 omCheckAddrSize(r->block1,nblocks*sizeof(int));
241 omCheckAddrSize(r->wvhdl,nblocks*sizeof(int *));
242 omCheckAddrSize(r->names,r->N*sizeof(char *));
243
244 nblocks--;
245
246
247 //Print("ref:%d, C->ref:%d\n",r->ref,C->ref);
248 PrintS("// coefficients: ");
249 if( nCoeff_is_algExt(C) )
250 {
251 // NOTE: the following (non-thread-safe!) UGLYNESS
252 // (changing naRing->ShortOut for a while) is due to Hans!
253 // Just think of other ring using the VERY SAME naRing and possible
254 // side-effects...
255 ring R = C->extRing;
256 const BOOLEAN bSaveShortOut = rShortOut(R); R->ShortOut = rShortOut(r) & rCanShortOut(R);
257
258 n_CoeffWrite(C, details); // for correct printing of minpoly... WHAT AN UGLYNESS!!!
259
260 R->ShortOut = bSaveShortOut;
261 }
262 else
264 PrintLn();
265// {
266// PrintS("// characteristic : ");
267//
268// char const * const * const params = rParameter(r);
269//
270// if (params!=NULL)
271// {
272// Print ("// %d parameter : ",rPar(r));
273//
274// char const * const * sp= params;
275// int nop=0;
276// while (nop<rPar(r))
277// {
278// PrintS(*sp);
279// PrintS(" ");
280// sp++; nop++;
281// }
282// PrintS("\n// minpoly : ");
283// if ( rField_is_long_C(r) )
284// {
285// // i^2+1:
286// Print("(%s^2+1)\n", params[0]);
287// }
288// else if (rMinpolyIsNULL(r))
289// {
290// PrintS("0\n");
291// }
292// else
293// {
294// StringSetS(""); n_Write(r->cf->minpoly, r); PrintS(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
295// }
296// //if (r->qideal!=NULL)
297// //{
298// // iiWriteMatrix((matrix)r->qideal,"// minpolys",1,r,0);
299// // PrintLn();
300// //}
301// }
302// }
303 Print("// number of vars : %d",r->N);
304
305 //for (nblocks=0; r->order[nblocks]; nblocks++);
306 nblocks=rBlocks(r)-1;
307
308 for (int l=0, nlen=0 ; l<nblocks; l++)
309 {
310 int i;
311 Print("\n// block %3d : ",l+1);
312
313 Print("ordering %s", rSimpleOrdStr(r->order[l]));
314
315
316 if (r->order[l] == ringorder_IS)
317 {
318 assume( r->block0[l] == r->block1[l] );
319 const int s = r->block0[l];
320 assume( (-2 < s) && (s < 2) );
321 Print("(%d)", s); // 0 => prefix! +/-1 => suffix!
322 continue;
323 }
324 else if (r->order[l]==ringorder_s)
325 {
326 assume( l == 0 );
327 Print(" syz_comp: %d",r->block0[l]);
328 continue;
329 }
330 else if (
331 ( (r->order[l] >= ringorder_lp)
332 ||(r->order[l] == ringorder_M)
333 ||(r->order[l] == ringorder_a)
334 ||(r->order[l] == ringorder_am)
335 ||(r->order[l] == ringorder_a64)
336 ||(r->order[l] == ringorder_aa) ) && (r->order[l] < ringorder_IS) )
337 {
338 PrintS("\n// : names ");
339 for (i = r->block0[l]-1; i<r->block1[l]; i++)
340 {
341 nlen = strlen(r->names[i]);
342 Print(" %s",r->names[i]);
343 }
344 }
345
346 if (r->wvhdl[l]!=NULL)
347 {
348 #ifndef SING_NDEBUG
349 if((r->order[l] != ringorder_wp)
350 &&(r->order[l] != ringorder_Wp)
351 &&(r->order[l] != ringorder_ws)
352 &&(r->order[l] != ringorder_Ws)
353 &&(r->order[l] != ringorder_a)
354 &&(r->order[l] != ringorder_a64)
355 &&(r->order[l] != ringorder_am)
356 &&(r->order[l] != ringorder_M))
357 {
358 Warn("should not have wvhdl entry at pos. %d",l);
359 }
360 #endif
361 for (int j= 0;
362 j<(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1);
363 j+=i)
364 {
365 PrintS("\n// : weights ");
366 for (i = 0; i<=r->block1[l]-r->block0[l]; i++)
367 {
368 if (r->order[l] == ringorder_a64)
369 {
370 int64 *w=(int64 *)r->wvhdl[l];
371 #if SIZEOF_LONG == 4
372 Print("%*lld " ,nlen,w[i+j]);
373 #else
374 Print(" %*ld" ,nlen,w[i+j]);
375 #endif
376 }
377 else
378 Print(" %*d" ,nlen,r->wvhdl[l][i+j]);
379 }
380 if (r->order[l]!=ringorder_M) break;
381 }
382 if (r->order[l]==ringorder_am)
383 {
384 int m=r->wvhdl[l][i];
385 Print("\n// : %d module weights ",m);
386 m+=i;i++;
387 for(;i<=m;i++) Print(" %*d" ,nlen,r->wvhdl[l][i]);
388 }
389 }
390 }
391#ifdef HAVE_PLURAL
392 if(rIsPluralRing(r))
393 {
394 PrintS("\n// noncommutative relations:");
395 if( details )
396 {
397 poly pl=NULL;
398 int nl;
399 int i,j;
400 for (i = 1; i<r->N; i++)
401 {
402 for (j = i+1; j<=r->N; j++)
403 {
404 nl = n_IsOne(p_GetCoeff(MATELEM(r->GetNC()->C,i,j),r), r->cf);
405 if ( (MATELEM(r->GetNC()->D,i,j)!=NULL) || (!nl) )
406 {
407 Print("\n// %s%s=",r->names[j-1],r->names[i-1]);
408 pl = MATELEM(r->GetNC()->MT[UPMATELEM(i,j,r->N)],1,1);
409 p_Write0(pl, r, r);
410 }
411 }
412 }
413 } else
414 PrintS(" ...");
415
416#if MYTEST /*Singularg should not differ from Singular except in error case*/
417 Print("\n// noncommutative type:%d", (int)ncRingType(r));
418 Print("\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
419 if( rIsSCA(r) )
420 {
421 Print("\n// alternating variables: [%d, %d]", scaFirstAltVar(r), scaLastAltVar(r));
422 const ideal Q = SCAQuotient(r); // resides within r!
423 PrintS("\n// quotient of sca by ideal");
424
425 if (Q!=NULL)
426 {
427 iiWriteMatrix((matrix)Q,"scaQ",1,r,0);
428 }
429 else
430 PrintS(" (NULL)");
431 }
432#endif
433 }
434 if (rIsLPRing(r))
435 {
436 Print("\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
437 }
438#endif
439 if (r->qideal!=NULL)
440 {
441 PrintS("\n// quotient ring from ideal");
442 if( details )
443 {
444 PrintLn();
445 iiWriteMatrix((matrix)r->qideal,"_",1,r,0);
446 } else PrintS(" ...");
447 }
448}
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition coeffs.h:716
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:465
#define UPMATELEM(i, j, nVar)
Definition nc.h:36
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
Definition matpol.cc:827
#define p_GetCoeff(p, r)
Definition monomials.h:50
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:332
static BOOLEAN rShortOut(const ring r)
Definition ring.h:581
static BOOLEAN rCanShortOut(const ring r)
Definition ring.h:586
ideal SCAQuotient(const ring r)
Definition sca.h:10

Variable Documentation

◆ sip_sring_bin

EXTERN_VAR omBin sip_sring_bin

Definition at line 831 of file ring.h.