My Project
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 More...
 
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! More...
 
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 char * rSimpleOrdStr (int ord)
 
rRingOrder_t rOrderName (char *ordername)
 
char * rOrdStr (ring r)
 
char * rVarStr (ring r)
 
char * rCharStr (ring r)
 TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar. More...
 
char * rString (ring r)
 
int rChar (ring r)
 
char * rParStr (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 More...
 
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 More...
 
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 More...
 
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. More...
 
static n_coeffType rFieldType (const ring r)
 the type of the coefficient filed of r (n_Zp, n_Q, etc) More...
 
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 More...
 
void p_SetGlobals (const ring r, BOOLEAN complete=TRUE)
 set all properties of a new ring - also called by rComplete More...
 
static int rBlocks (const ring r)
 
static char * rRingVar (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) More...
 
static int rPar (const ring r)
 (r->cf->P) More...
 
static char const ** rParameter (const ring r)
 (r->cf->parameter) More...
 
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! More...
 
int n_IsParam (number m, const ring r)
 if m == var(i)/1 => return i, More...
 
static int rInternalChar (const ring r)
 
static BOOLEAN rMinpolyIsNULL (const ring r)
 Tests whether '(r->cf->minpoly) == NULL'. More...
 
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_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 More...
 
ring rAssure_SyzComp_CompLastBlock (const ring r)
 makes sure that c/C ordering is last ordering and SyzIndex is first More...
 
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 More...
 
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 More...
 
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_SetCompRequiresSetm (const ring r)
 return TRUE if p_SetComp requires p_Setm More...
 
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 More...
 
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! More...
 
int rGetISPos (const int p, const ring r)
 return the position of the p^th IS block order block in r->typ[]... More...
 
BOOLEAN rCheckIV (const intvec *iv)
 
int rTypeOfMatrixOrder (const intvec *order)
 
void rDelete (ring r)
 unconditionally deletes fields in r More...
 
ring rPlusVar (const ring r, char *v, int left)
 K[x],"y" -> K[x,y] resp. K[y,x]. More...
 
ring rMinusVar (const ring r, char *v)
 undo rPlusVar More...
 
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
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 782 of file ring.h.

Typedef Documentation

◆ BBA_Proc

typedef ideal(* BBA_Proc) (const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring)

Definition at line 244 of file ring.h.

◆ idhdl

typedef idrec* idhdl

Definition at line 21 of file ring.h.

◆ kBucket_pt

typedef kBucket* 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

typedef struct p_Procs_s p_Procs_s

Definition at line 21 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

enum 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)
62  ro_none
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
110 } rOrderType_t;
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
95 } rRingOrder_t;
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 5773 of file ring.cc.

5774 {
5775  assume(r != NULL);
5776  const coeffs C = r->cf;
5777  assume(C != NULL);
5778 
5780 
5781  const n_coeffType _filed_type = getCoeffType(C);
5782 
5783  if(( _filed_type == n_algExt )||( _filed_type == n_polyExt ))
5784  return naIsParam(m, C);
5785 
5786  if( _filed_type == n_transExt )
5787  return ntIsParam(m, C);
5788 
5789  Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C));
5790 
5791  return 0;
5792 }
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 4327 of file ring.cc.

4328 {
4329  int i,j;
4330  p_Write(p,r);
4331  j=2;
4332  while(p!=NULL)
4333  {
4334  Print("\nexp[0..%d]\n",r->ExpL_Size-1);
4335  for(i=0;i<r->ExpL_Size;i++)
4336  Print("%ld ",p->exp[i]);
4337  PrintLn();
4338  Print("v0:%ld ",p_GetComp(p, r));
4339  for(i=1;i<=r->N;i++) Print(" v%d:%ld",i,p_GetExp(p,i, r));
4340  PrintLn();
4341  pIter(p);
4342  j--;
4343  if (j==0) { PrintS("...\n"); break; }
4344  }
4345 }
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:467
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 3415 of file ring.cc.

3416 {
3417 // // // if (r->ppNoether!=NULL) p_Delete(&r->ppNoether,r); // ???
3418 
3419  r->pLexOrder=r->LexOrder;
3420  if (complete)
3421  {
3423  si_opt_1 |= r->options;
3424  }
3425 }
VAR unsigned si_opt_1
Definition: options.c:5
#define TEST_RINGDEP_OPTS
Definition: options.h:101

◆ 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 4985 of file ring.cc.

4986 {
4988 }
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
Definition: ring.cc:4804

◆ rAssure_c_dp()

ring rAssure_c_dp ( const ring  r)

Definition at line 4990 of file ring.cc.

4991 {
4993 }

◆ rAssure_CompLastBlock()

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

makes sure that c/C ordering is last ordering

Definition at line 4694 of file ring.cc.

4695 {
4696  int last_block = rBlocks(r) - 2;
4697  if (r->order[last_block] != ringorder_c &&
4698  r->order[last_block] != ringorder_C)
4699  {
4700  int c_pos = 0;
4701  int i;
4702 
4703  for (i=0; i< last_block; i++)
4704  {
4705  if (r->order[i] == ringorder_c || r->order[i] == ringorder_C)
4706  {
4707  c_pos = i;
4708  break;
4709  }
4710  }
4711  if (c_pos != -1)
4712  {
4713  ring new_r = rCopy0(r, FALSE, TRUE);
4714  for (i=c_pos+1; i<=last_block; i++)
4715  {
4716  new_r->order[i-1] = new_r->order[i];
4717  new_r->block0[i-1] = new_r->block0[i];
4718  new_r->block1[i-1] = new_r->block1[i];
4719  new_r->wvhdl[i-1] = new_r->wvhdl[i];
4720  }
4721  new_r->order[last_block] = r->order[c_pos];
4722  new_r->block0[last_block] = r->block0[c_pos];
4723  new_r->block1[last_block] = r->block1[c_pos];
4724  new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4725  if (complete)
4726  {
4727  rComplete(new_r, 1);
4728 
4729 #ifdef HAVE_PLURAL
4730  if (rIsPluralRing(r))
4731  {
4732  if ( nc_rComplete(r, new_r, false) ) // no qideal!
4733  {
4734 #ifndef SING_NDEBUG
4735  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4736 #endif
4737  }
4738  }
4739  assume(rIsPluralRing(r) == rIsPluralRing(new_r));
4740 #endif
4741  }
4742  return new_r;
4743  }
4744  }
4745  return r;
4746 }
#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:3450
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition: ring.cc:5685
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 4980 of file ring.cc.

4981 {
4983 }

◆ rAssure_dp_S()

ring rAssure_dp_S ( const ring  r)

Definition at line 4975 of file ring.cc.

4976 {
4978 }

◆ rAssure_HasComp()

ring rAssure_HasComp ( const ring  r)

Definition at line 4625 of file ring.cc.

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

◆ rAssure_InducedSchreyerOrdering()

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

Definition at line 4850 of file ring.cc.

4851 { // TODO: ???? Add leading Syz-comp ordering here...????
4852 
4853 #if MYTEST
4854  Print("rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
4855  rWrite(r);
4856 #ifdef RDEBUG
4857  rDebugPrint(r);
4858 #endif
4859  PrintLn();
4860 #endif
4861  assume((sgn == 1) || (sgn == -1));
4862 
4863  ring res=rCopy0(r, FALSE, FALSE); // No qideal & ordering copy.
4864 
4865  int n = rBlocks(r); // Including trailing zero!
4866 
4867  // Create 2 more blocks for prefix/suffix:
4868  res->order=(rRingOrder_t *)omAlloc0((n+2)*sizeof(rRingOrder_t)); // 0 .. n+1
4869  res->block0=(int *)omAlloc0((n+2)*sizeof(int));
4870  res->block1=(int *)omAlloc0((n+2)*sizeof(int));
4871  int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
4872 
4873  // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
4874  // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
4875 
4876  // new 1st block
4877  int j = 0;
4878  res->order[j] = ringorder_IS; // Prefix
4879  res->block0[j] = res->block1[j] = 0;
4880  // wvhdl[j] = NULL;
4881  j++;
4882 
4883  for(int i = 0; (i <= n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
4884  {
4885  res->order [j] = r->order [i];
4886  res->block0[j] = r->block0[i];
4887  res->block1[j] = r->block1[i];
4888 
4889  if (r->wvhdl[i] != NULL)
4890  {
4891  #ifdef HAVE_OMALLOC
4892  wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
4893  #else
4894  {
4895  int l=(r->block1[i]-r->block0[i]+1);
4896  if (r->order[i]==ringorder_a64) l*=2;
4897  else if (r->order[i]==ringorder_M) l=l*l;
4898  else if (r->order[i]==ringorder_am)
4899  {
4900  l+=r->wvhdl[i][r->block1[i]-r->block0[i]+1]+1;
4901  }
4902  wvhdl[j]=(int*)omalloc(l*sizeof(int));
4903  memcpy(wvhdl[j],r->wvhdl[i],l*sizeof(int));
4904  }
4905  #endif
4906  } // else wvhdl[j] = NULL;
4907  }
4908 
4909  // new last block
4910  res->order [j] = ringorder_IS; // Suffix
4911  res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
4912  // wvhdl[j] = NULL;
4913  j++;
4914 
4915  // res->order [j] = 0; // The End!
4916  res->wvhdl = wvhdl;
4917 
4918  // j == the last zero block now!
4919  assume(j == (n+1));
4920  assume(res->order[0]==ringorder_IS);
4921  assume(res->order[j-1]==ringorder_IS);
4922  assume(res->order[j]==0);
4923 
4924 
4925  if (complete)
4926  {
4927  rComplete(res, 1);
4928 
4929 #ifdef HAVE_PLURAL
4930  if (rIsPluralRing(r))
4931  {
4932  if ( nc_rComplete(r, res, false) ) // no qideal!
4933  {
4934 #ifndef SING_NDEBUG
4935  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4936 #endif
4937  }
4938  }
4940 #endif
4941 
4942 
4943 #ifdef HAVE_PLURAL
4944  ring old_ring = r;
4945 #endif
4946 
4947  if (r->qideal!=NULL)
4948  {
4949  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4950 
4951  assume(id_RankFreeModule(res->qideal, res) == 0);
4952 
4953 #ifdef HAVE_PLURAL
4954  if( rIsPluralRing(res) )
4955  if( nc_SetupQuotient(res, r, true) )
4956  {
4957 // WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4958  }
4959 
4960 #endif
4961  assume(id_RankFreeModule(res->qideal, res) == 0);
4962  }
4963 
4964 #ifdef HAVE_PLURAL
4965  assume((res->qideal==NULL) == (old_ring->qideal==NULL));
4966  assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
4967  assume(rIsSCA(res) == rIsSCA(old_ring));
4968  assume(ncRingType(res) == ncRingType(old_ring));
4969 #endif
4970  }
4971 
4972  return res;
4973 }
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)
Definition: old.gring.cc:3411
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:4122
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 4435 of file ring.cc.

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

◆ 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 4749 of file ring.cc.

4750 {
4751  rTest(r);
4752 
4753  ring new_r_1 = rAssure_CompLastBlock(r, FALSE); // due to this FALSE - no completion!
4754  ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
4755 
4756  if (new_r == r)
4757  return r;
4758 
4759  ring old_r = r;
4760  if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
4761 
4762  rComplete(new_r, TRUE);
4763 #ifdef HAVE_PLURAL
4764  if (rIsPluralRing(old_r))
4765  {
4766  if ( nc_rComplete(old_r, new_r, false) ) // no qideal!
4767  {
4768 # ifndef SING_NDEBUG
4769  WarnS("error in nc_rComplete"); // cleanup? rDelete(res); return r; // just go on...?
4770 # endif
4771  }
4772  }
4773 #endif
4774 
4775 ///? rChangeCurrRing(new_r);
4776  if (old_r->qideal != NULL)
4777  {
4778  new_r->qideal = idrCopyR(old_r->qideal, old_r, new_r);
4779  }
4780 
4781 #ifdef HAVE_PLURAL
4782  if( rIsPluralRing(old_r) )
4783  if( nc_SetupQuotient(new_r, old_r, true) )
4784  {
4785 #ifndef SING_NDEBUG
4786  WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4787 #endif
4788  }
4789 #endif
4790 
4791 #ifdef HAVE_PLURAL
4792  assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
4793  assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
4794  assume(rIsSCA(new_r) == rIsSCA(old_r));
4795  assume(ncRingType(new_r) == ncRingType(old_r));
4796 #endif
4797 
4798  rTest(new_r);
4799  rTest(old_r);
4800  return new_r;
4801 }
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:4435
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:4694
#define rTest(r)
Definition: ring.h:782

◆ rAssure_SyzOrder()

ring rAssure_SyzOrder ( const ring  r,
BOOLEAN  complete 
)

Definition at line 4430 of file ring.cc.

4431 {
4432  if ( r->order[0] == ringorder_c ) return r;
4433  return rAssure_SyzComp(r,complete);
4434 }

◆ rAssure_TDeg()

ring rAssure_TDeg ( const ring  r,
int &  pos 
)

Definition at line 4527 of file ring.cc.

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

◆ 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 4405 of file ring.cc.

4406 {
4407 #ifdef PDEBUG
4408  rDBChangeSComps(currComponents, currShiftedComponents, length, r);
4409 #else
4410  rNChangeSComps(currComponents, currShiftedComponents, r);
4411 #endif
4412 }
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
Definition: ring.cc:4367
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4383
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 3450 of file ring.cc.

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

◆ rCopy()

ring rCopy ( ring  r)

Definition at line 1731 of file ring.cc.

1732 {
1733  if (r == NULL) return NULL;
1734  ring res=rCopy0(r,FALSE,TRUE);
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)
Definition: old.gring.cc:3011

◆ 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;
1425  ring res=(ring)omAlloc0Bin(sip_sring_bin);
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  {
1547  assume(copy_ordering);
1548  rComplete(res);
1549  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
1550  rUnComplete(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)
Definition: omAllocDecl.h:263
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
VAR omBin sip_sring_bin
Definition: ring.cc:43
void rUnComplete(ring r)
Definition: ring.cc:3965
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;
1568  ring res=(ring)omAlloc0Bin(sip_sring_bin);
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);
1715  rUnComplete(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 }
int rows() const
Definition: int64vec.h:66
#define A
Definition: sirandom.c:24

◆ rDBTest()

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

Definition at line 2038 of file ring.cc.

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

◆ rDebugPrint()

void rDebugPrint ( const ring  r)

Definition at line 4122 of file ring.cc.

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

838 { 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);
105  ring r=(ring) omAlloc0Bin(sip_sring_bin);
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:413

◆ 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:568
void nc_rKill(ring r)
complete destructor
Definition: old.gring.cc:2483
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259

◆ rEnvelope()

ring rEnvelope ( ring  r)

Definition at line 5671 of file ring.cc.

5674 {
5675  ring Ropp = rOpposite(R);
5676  ring Renv = NULL;
5677  int stat = rSum(R, Ropp, Renv); /* takes care of qideals */
5678  if ( stat <=0 )
5679  WarnS("Error in rEnvelope at rSum");
5680  rTest(Renv);
5681  return Renv;
5682 }
int rSum(ring r1, ring r2, ring &sum)
Definition: ring.cc:1402
ring rOpposite(ring src)
Definition: ring.cc:5281
#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:4508
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)
Definition: simpleideals.h:23

◆ 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 2663 of file ring.cc.

2664 {
2665  bitmask =rGetExpSize(bitmask, bits);
2666  int vars_per_long=BIT_SIZEOF_LONG/bits;
2667  int bits1;
2668  loop
2669  {
2670  if (bits == BIT_SIZEOF_LONG-1)
2671  {
2672  bits = BIT_SIZEOF_LONG - 1;
2673  return LONG_MAX;
2674  }
2675  unsigned long bitmask1 =rGetExpSize(bitmask+1, bits1);
2676  int vars_per_long1=BIT_SIZEOF_LONG/bits1;
2677  if ((((N+vars_per_long-1)/vars_per_long) ==
2678  ((N+vars_per_long1-1)/vars_per_long1)))
2679  {
2680  vars_per_long=vars_per_long1;
2681  bits=bits1;
2682  bitmask=bitmask1;
2683  }
2684  else
2685  {
2686  return bitmask; /* and bits */
2687  }
2688  }
2689 }
#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 5000 of file ring.cc.

5001 {
5002  // Put the reference set F into the ring -ordering -recor
5003 #if MYTEST
5004  Print("rIsIS(p: %d)\nF:", p);
5005  PrintLn();
5006 #endif
5007 
5008  if (r->typ==NULL)
5009  {
5010 // dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
5011  return -1;
5012  }
5013 
5014  int j = p; // Which IS record to use...
5015  for( int pos = 0; pos < r->OrdSize; pos++ )
5016  if( r->typ[pos].ord_typ == ro_is)
5017  if( j-- == 0 )
5018  return pos;
5019 
5020  return -1;
5021 }

◆ rGetMaxSyzComp()

int rGetMaxSyzComp ( int  i,
const ring  r 
)

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

Definition at line 5158 of file ring.cc.

5159 {
5160  if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz) &&
5161  r->typ[0].data.syz.limit > 0 && i > 0)
5162  {
5163  assume(i <= r->typ[0].data.syz.limit);
5164  int j;
5165  for (j=0; j<r->typ[0].data.syz.limit; j++)
5166  {
5167  if (r->typ[0].data.syz.syz_index[j] == i &&
5168  r->typ[0].data.syz.syz_index[j+1] != i)
5169  {
5170  assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5171  return j;
5172  }
5173  }
5174  return r->typ[0].data.syz.limit;
5175  }
5176  else
5177  {
5178  #ifndef SING_NDEBUG
5179  WarnS("rGetMaxSyzComp: order c");
5180  #endif
5181  return 0;
5182  }
5183 }

◆ 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 4414 of file ring.cc.

4415 {
4416 #ifdef PDEBUG
4417  rDBGetSComps(currComponents, currShiftedComponents, length, r);
4418 #else
4419  rNGetSComps(currComponents, currShiftedComponents, r);
4420 #endif
4421 }
static void rNGetSComps(int **currComponents, long **currShiftedComponents, ring r)
Definition: ring.cc:4375
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition: ring.cc:4393

◆ rGetVar()

poly rGetVar ( const int  varIndex,
const ring  r 
)

Definition at line 5763 of file ring.cc.

5764 {
5765  poly p = p_ISet(1, r);
5766  p_SetExp(p, varIndex, 1, r);
5767  p_Setm(p, r);
5768  return p;
5769 }
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:486
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231

◆ rGetWeightVec()

int64* rGetWeightVec ( const ring  r)

Definition at line 5222 of file ring.cc.

5223 {
5224  assume(r!=NULL);
5225  assume(r->OrdSize>0);
5226  int i=0;
5227  while((r->typ[i].ord_typ!=ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5228  if (r->typ[i].ord_typ!=ro_wp64) return NULL; /* should not happen*/
5229  return r->typ[i].data.wp64.weights64;
5230 }

◆ 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 759 of file ring.h.

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

◆ rHasLocalOrMixedOrdering()

BOOLEAN rHasLocalOrMixedOrdering ( const ring  r)
inline

Definition at line 760 of file ring.h.

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

◆ rHasMixedOrdering()

BOOLEAN rHasMixedOrdering ( const ring  r)
inline

Definition at line 761 of file ring.h.

761 { 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 837 of file ring.h.

837 { 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 3069 of file ring.cc.

3070 {
3071  rUnComplete(r);
3072  omFree(r->order);
3073  omFree(r->block0);
3074  omFree(r->block1);
3075  omFree(r->wvhdl[0]);
3076  omFree(r->wvhdl);
3078 }

◆ rKillModifiedRing()

void rKillModifiedRing ( ring  r)

Definition at line 3059 of file ring.cc.

3060 {
3061  rUnComplete(r);
3062  omFree(r->order);
3063  omFree(r->block0);
3064  omFree(r->block1);
3065  omFree(r->wvhdl);
3067 }

◆ 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 );
710  BOOLEAN idIs0 (ideal h);
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 5876 of file ring.cc.

5877 {
5878  if (r->order[2]!=0)
5879  {
5880  WerrorS("only for rings with an ordering of one block");
5881  return NULL;
5882  }
5883  int p;
5884  if((r->order[0]==ringorder_C)
5885  ||(r->order[0]==ringorder_c))
5886  p=1;
5887  else
5888  p=0;
5889  if((r->order[p]!=ringorder_dp)
5890  && (r->order[p]!=ringorder_Dp)
5891  && (r->order[p]!=ringorder_lp)
5892  && (r->order[p]!=ringorder_rp)
5893  && (r->order[p]!=ringorder_ds)
5894  && (r->order[p]!=ringorder_Ds)
5895  && (r->order[p]!=ringorder_ls))
5896  {
5897  WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5898  return NULL;
5899  }
5900  ring R=rCopy0(r);
5901  int i=R->N-1;
5902  while(i>=0)
5903  {
5904  if (strcmp(R->names[i],v)==0)
5905  {
5906  R->N--;
5907  omFree(R->names[i]);
5908  for(int j=i;j<R->N;j++) R->names[j]=R->names[j+1];
5909  R->names=(char**)omReallocSize(R->names,r->N*sizeof(char_ptr),R->N*sizeof(char_ptr));
5910  }
5911  i--;
5912  }
5913  R->block1[p]=R->N;
5914  rComplete(R,1);
5915  return R;
5916 }
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220
char * char_ptr
Definition: structs.h:53

◆ 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 2698 of file ring.cc.

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

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

◆ rModifyRing_Wp()

ring rModifyRing_Wp ( ring  r,
int *  weights 
)

construct Wp, C ring

Definition at line 2945 of file ring.cc.

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

◆ rOpposite()

ring rOpposite ( ring  r)

Definition at line 5281 of file ring.cc.

5285 {
5286  if (src == NULL) return(NULL);
5287 
5288  //rChangeCurrRing(src);
5289 #ifdef RDEBUG
5290  rTest(src);
5291 // rWrite(src);
5292 // rDebugPrint(src);
5293 #endif
5294 
5295  ring r = rCopy0(src,FALSE);
5296  if (src->qideal != NULL)
5297  {
5298  id_Delete(&(r->qideal), src);
5299  }
5300 
5301  // change vars v1..vN -> vN..v1
5302  int i;
5303  int i2 = (rVar(r)-1)/2;
5304  for(i=i2; i>=0; i--)
5305  {
5306  // index: 0..N-1
5307  //Print("ex var names: %d <-> %d\n",i,rOppVar(r,i));
5308  // exchange names
5309  char *p;
5310  p = r->names[rVar(r)-1-i];
5311  r->names[rVar(r)-1-i] = r->names[i];
5312  r->names[i] = p;
5313  }
5314 // i2=(rVar(r)+1)/2;
5315 // for(int i=i2; i>0; i--)
5316 // {
5317 // // index: 1..N
5318 // //Print("ex var places: %d <-> %d\n",i,rVar(r)+1-i);
5319 // // exchange VarOffset
5320 // int t;
5321 // t=r->VarOffset[i];
5322 // r->VarOffset[i]=r->VarOffset[rOppVar(r,i)];
5323 // r->VarOffset[rOppVar(r,i)]=t;
5324 // }
5325  // change names:
5326  // TODO: does this work the same way for Letterplace?
5327  for (i=rVar(r)-1; i>=0; i--)
5328  {
5329  char *p=r->names[i];
5330  if(isupper(*p)) *p = tolower(*p);
5331  else *p = toupper(*p);
5332  }
5333  // change ordering: listing
5334  // change ordering: compare
5335 // for(i=0; i<r->OrdSize; i++)
5336 // {
5337 // int t,tt;
5338 // switch(r->typ[i].ord_typ)
5339 // {
5340 // case ro_dp:
5341 // //
5342 // t=r->typ[i].data.dp.start;
5343 // r->typ[i].data.dp.start=rOppVar(r,r->typ[i].data.dp.end);
5344 // r->typ[i].data.dp.end=rOppVar(r,t);
5345 // break;
5346 // case ro_wp:
5347 // case ro_wp_neg:
5348 // {
5349 // t=r->typ[i].data.wp.start;
5350 // r->typ[i].data.wp.start=rOppVar(r,r->typ[i].data.wp.end);
5351 // r->typ[i].data.wp.end=rOppVar(r,t);
5352 // // invert r->typ[i].data.wp.weights
5353 // rOppWeight(r->typ[i].data.wp.weights,
5354 // r->typ[i].data.wp.end-r->typ[i].data.wp.start);
5355 // break;
5356 // }
5357 // //case ro_wp64:
5358 // case ro_syzcomp:
5359 // case ro_syz:
5360 // WerrorS("not implemented in rOpposite");
5361 // // should not happen
5362 // break;
5363 //
5364 // case ro_cp:
5365 // t=r->typ[i].data.cp.start;
5366 // r->typ[i].data.cp.start=rOppVar(r,r->typ[i].data.cp.end);
5367 // r->typ[i].data.cp.end=rOppVar(r,t);
5368 // break;
5369 // case ro_none:
5370 // default:
5371 // Werror("unknown type in rOpposite(%d)",r->typ[i].ord_typ);
5372 // break;
5373 // }
5374 // }
5375  // Change order/block structures (needed for rPrint, rAdd etc.)
5376 
5377  int j=0;
5378  int l=rBlocks(src);
5379  if ( ! rIsLPRing(src) )
5380  {
5381  // ie Plural or commutative
5382  for(i=0; src->order[i]!=0; i++)
5383  {
5384  switch (src->order[i])
5385  {
5386  case ringorder_c: /* c-> c */
5387  case ringorder_C: /* C-> C */
5388  case ringorder_no /*=0*/: /* end-of-block */
5389  r->order[j]=src->order[i];
5390  j++; break;
5391  case ringorder_lp: /* lp -> rp */
5392  r->order[j]=ringorder_rp;
5393  r->block0[j]=rOppVar(r, src->block1[i]);
5394  r->block1[j]=rOppVar(r, src->block0[i]);
5395  j++;break;
5396  case ringorder_rp: /* rp -> lp */
5397  r->order[j]=ringorder_lp;
5398  r->block0[j]=rOppVar(r, src->block1[i]);
5399  r->block1[j]=rOppVar(r, src->block0[i]);
5400  j++;break;
5401  case ringorder_dp: /* dp -> a(1..1),ls */
5402  {
5403  l=rRealloc1(r,l,j);
5404  r->order[j]=ringorder_a;
5405  r->block0[j]=rOppVar(r, src->block1[i]);
5406  r->block1[j]=rOppVar(r, src->block0[i]);
5407  r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
5408  for(int k=r->block0[j]; k<=r->block1[j]; k++)
5409  r->wvhdl[j][k-r->block0[j]]=1;
5410  j++;
5411  r->order[j]=ringorder_ls;
5412  r->block0[j]=rOppVar(r, src->block1[i]);
5413  r->block1[j]=rOppVar(r, src->block0[i]);
5414  j++;
5415  break;
5416  }
5417  case ringorder_Dp: /* Dp -> a(1..1),rp */
5418  {
5419  l=rRealloc1(r,l,j);
5420  r->order[j]=ringorder_a;
5421  r->block0[j]=rOppVar(r, src->block1[i]);
5422  r->block1[j]=rOppVar(r, src->block0[i]);
5423  r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
5424  for(int k=r->block0[j]; k<=r->block1[j]; k++)
5425  r->wvhdl[j][k-r->block0[j]]=1;
5426  j++;
5427  r->order[j]=ringorder_rp;
5428  r->block0[j]=rOppVar(r, src->block1[i]);
5429  r->block1[j]=rOppVar(r, src->block0[i]);
5430  j++;
5431  break;
5432  }
5433  case ringorder_wp: /* wp -> a(...),ls */
5434  {
5435  l=rRealloc1(r,l,j);
5436  r->order[j]=ringorder_a;
5437  r->block0[j]=rOppVar(r, src->block1[i]);
5438  r->block1[j]=rOppVar(r, src->block0[i]);
5439  r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
5440  rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5441  j++;
5442  r->order[j]=ringorder_ls;
5443  r->block0[j]=rOppVar(r, src->block1[i]);
5444  r->block1[j]=rOppVar(r, src->block0[i]);
5445  j++;
5446  break;
5447  }
5448  case ringorder_Wp: /* Wp -> a(...),rp */
5449  {
5450  l=rRealloc1(r,l,j);
5451  r->order[j]=ringorder_a;
5452  r->block0[j]=rOppVar(r, src->block1[i]);
5453  r->block1[j]=rOppVar(r, src->block0[i]);
5454  r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
5455  rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5456  j++;
5457  r->order[j]=ringorder_rp;
5458  r->block0[j]=rOppVar(r, src->block1[i]);
5459  r->block1[j]=rOppVar(r, src->block0[i]);
5460  j++;
5461  break;
5462  }
5463  case ringorder_M: /* M -> M */
5464  {
5465  r->order[j]=ringorder_M;
5466  r->block0[j]=rOppVar(r, src->block1[i]);
5467  r->block1[j]=rOppVar(r, src->block0[i]);
5468  int n=r->block1[j]-r->block0[j];
5469  /* M is a (n+1)x(n+1) matrix */
5470  for (int nn=0; nn<=n; nn++)
5471  {
5472  rOppWeight(&(r->wvhdl[j][nn*(n+1)]), n /*r->block1[j]-r->block0[j]*/);
5473  }
5474  j++;
5475  break;
5476  }
5477  case ringorder_a: /* a(...),ls -> wp/dp */
5478  {
5479  r->block0[j]=rOppVar(r, src->block1[i]);
5480  r->block1[j]=rOppVar(r, src->block0[i]);
5481  rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5482  if (src->order[i+1]==ringorder_ls)
5483  {
5484  r->order[j]=ringorder_wp;
5485  i++;
5486  //l=rReallocM1(r,l,j);
5487  }
5488  else
5489  {
5490  r->order[j]=ringorder_a;
5491  }
5492  j++;
5493  break;
5494  }
5495  // not yet done:
5496  case ringorder_ls:
5497  case ringorder_rs:
5498  case ringorder_ds:
5499  case ringorder_Ds:
5500  case ringorder_ws:
5501  case ringorder_Ws:
5502  case ringorder_am:
5503  case ringorder_a64:
5504  // should not occur:
5505  case ringorder_S:
5506  case ringorder_IS:
5507  case ringorder_s:
5508  case ringorder_aa:
5509  case ringorder_L:
5510  case ringorder_unspec:
5511  Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5512  break;
5513  }
5514  }
5515  } /* end if (!rIsLPRing(src)) */
5516  if (rIsLPRing(src))
5517  {
5518  // applies to Letterplace only
5519  // Letterplace conventions: dp<->Dp, lp<->rp
5520  // Wp(v) cannot be converted since wp(v) does not encode a monomial ordering
5521  // (a(w),<) is troublesome and thus postponed
5522  for(i=0; src->order[i]!=0; i++)
5523  {
5524  switch (src->order[i])
5525  {
5526  case ringorder_c: /* c-> c */
5527  case ringorder_C: /* C-> C */
5528  case ringorder_no /*=0*/: /* end-of-block */
5529  r->order[j]=src->order[i];
5530  j++; break;
5531  case ringorder_lp: /* lp -> rp */
5532  r->order[j]=ringorder_rp;
5533  r->block0[j]=rOppVar(r, src->block1[i]);
5534  r->block1[j]=rOppVar(r, src->block0[i]);
5535  j++;break;
5536  case ringorder_rp: /* rp -> lp */
5537  r->order[j]=ringorder_lp;
5538  r->block0[j]=rOppVar(r, src->block1[i]);
5539  r->block1[j]=rOppVar(r, src->block0[i]);
5540  j++;break;
5541  case ringorder_dp: /* dp -> Dp */
5542  {
5543  r->order[j]=ringorder_Dp;
5544  r->block0[j]=rOppVar(r, src->block1[i]);
5545  r->block1[j]=rOppVar(r, src->block0[i]);
5546  j++;break;
5547  }
5548  case ringorder_Dp: /* Dp -> dp*/
5549  {
5550  r->order[j]=ringorder_dp;
5551  r->block0[j]=rOppVar(r, src->block1[i]);
5552  r->block1[j]=rOppVar(r, src->block0[i]);
5553  j++;break;
5554  }
5555  // not clear how to do:
5556  case ringorder_wp:
5557  case ringorder_Wp:
5558  case ringorder_M:
5559  case ringorder_a:
5560  // not yet done:
5561  case ringorder_ls:
5562  case ringorder_rs:
5563  case ringorder_ds:
5564  case ringorder_Ds:
5565  case ringorder_ws:
5566  case ringorder_Ws:
5567  case ringorder_am:
5568  case ringorder_a64:
5569  // should not occur:
5570  case ringorder_S:
5571  case ringorder_IS:
5572  case ringorder_s:
5573  case ringorder_aa:
5574  case ringorder_L:
5575  case ringorder_unspec:
5576  Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5577  break;
5578  }
5579  }
5580  } /* end if (rIsLPRing(src)) */
5581  rComplete(r);
5582 
5583  //rChangeCurrRing(r);
5584 #ifdef RDEBUG
5585  rTest(r);
5586 // rWrite(r);
5587 // rDebugPrint(r);
5588 #endif
5589 
5590 #ifdef HAVE_PLURAL
5591  // now, we initialize a non-comm structure on r
5592  if (rIsPluralRing(src))
5593  {
5594 // assume( currRing == r);
5595 
5596  int *perm = (int *)omAlloc0((rVar(r)+1)*sizeof(int));
5597  int *par_perm = NULL;
5598  nMapFunc nMap = n_SetMap(src->cf,r->cf);
5599  int ni,nj;
5600  for(i=1; i<=r->N; i++)
5601  {
5602  perm[i] = rOppVar(r,i);
5603  }
5604 
5605  matrix C = mpNew(rVar(r),rVar(r));
5606  matrix D = mpNew(rVar(r),rVar(r));
5607 
5608  for (i=1; i< rVar(r); i++)
5609  {
5610  for (j=i+1; j<=rVar(r); j++)
5611  {
5612  ni = r->N +1 - i;
5613  nj = r->N +1 - j; /* i<j ==> nj < ni */
5614 
5615  assume(MATELEM(src->GetNC()->C,i,j) != NULL);
5616  MATELEM(C,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,r, nMap,par_perm,rPar(src));
5617 
5618  if(MATELEM(src->GetNC()->D,i,j) != NULL)
5619  MATELEM(D,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,r, nMap,par_perm,rPar(src));
5620  }
5621  }
5622 
5623  id_Test((ideal)C, r);
5624  id_Test((ideal)D, r);
5625 
5626  if (nc_CallPlural(C, D, NULL, NULL, r, false, false, true, r)) // no qring setup!
5627  WarnS("Error initializing non-commutative multiplication!");
5628 
5629 #ifdef RDEBUG
5630  rTest(r);
5631 // rWrite(r);
5632 // rDebugPrint(r);
5633 #endif
5634 
5635  assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5636 
5637  omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
5638  }
5639 #endif /* HAVE_PLURAL */
5640 
5641  /* now oppose the qideal for qrings */
5642  if (src->qideal != NULL)
5643  {
5644 #ifdef HAVE_PLURAL
5645  r->qideal = idOppose(src, src->qideal, r); // into the currRing: r
5646 #else
5647  r->qideal = id_Copy(src->qideal, r); // ?
5648 #endif
5649 
5650 #ifdef HAVE_PLURAL
5651  if( rIsPluralRing(r) )
5652  {
5653  nc_SetupQuotient(r);
5654 #ifdef RDEBUG
5655  rTest(r);
5656 // rWrite(r);
5657 // rDebugPrint(r);
5658 #endif
5659  }
5660 #endif
5661  }
5662 #ifdef HAVE_PLURAL
5663  if( rIsPluralRing(r) )
5664  assume( ncRingType(r) == ncRingType(src) );
5665 #endif
5666  rTest(r);
5667 
5668  return r;
5669 }
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)
Definition: old.gring.cc:3389
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,...
Definition: old.gring.cc:2690
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:4126
const char * rSimpleOrdStr(int ord)
Definition: ring.cc:77
#define rOppVar(R, I)
Definition: ring.cc:5278
static void rOppWeight(int *w, int l)
Definition: ring.cc:5265
static int rRealloc1(ring r, int size, int pos)
Definition: ring.cc:5242
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:599
#define id_Test(A, lR)
Definition: simpleideals.h:87

◆ rOrd_is_Comp_dp()

static BOOLEAN rOrd_is_Comp_dp ( const ring  r)
inlinestatic

Definition at line 772 of file ring.h.

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

◆ 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);
517  omFree((ADDRESS)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;
614  if (mm>MAX_INT_VAL) mm=MAX_INT_VAL;
615  StringAppend(",L(%ld)",mm);
616  }
617  return StringEndS();
618  }
619  StringAppendS(",");
620  }
621 }
for(int i=0;i<=n;i++) degsf[i]
Definition: cfEzgcd.cc:72
#define StringAppend
Definition: emacs.cc:79
const CanonicalForm & w
Definition: facAbsFact.cc:51
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 5794 of file ring.cc.

5795 {
5796  if (r->order[2]!=0)
5797  {
5798  WerrorS("only for rings with an ordering of one block");
5799  return NULL;
5800  }
5801  int p;
5802  if((r->order[0]==ringorder_C)
5803  ||(r->order[0]==ringorder_c))
5804  p=1;
5805  else
5806  p=0;
5807  if((r->order[p]!=ringorder_dp)
5808  && (r->order[p]!=ringorder_Dp)
5809  && (r->order[p]!=ringorder_lp)
5810  && (r->order[p]!=ringorder_rp)
5811  && (r->order[p]!=ringorder_ds)
5812  && (r->order[p]!=ringorder_Ds)
5813  && (r->order[p]!=ringorder_ls))
5814  {
5815  WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5816  return NULL;
5817  }
5818  for(int i=r->N-1;i>=0;i--)
5819  {
5820  if (strcmp(r->names[i],v)==0)
5821  {
5822  Werror("duplicate variable name >>%s<<",v);
5823  return NULL;
5824  }
5825  }
5826  ring R=rCopy0(r);
5827  char **names;
5828  #ifdef HAVE_SHIFTBBA
5829  if (rIsLPRing(r))
5830  {
5831  R->isLPring=r->isLPring+1;
5832  R->N=((r->N)/r->isLPring)+r->N;
5833  names=(char**)omAlloc(R->N*sizeof(char_ptr));
5834  if (left)
5835  {
5836  for(int b=0;b<((r->N)/r->isLPring);b++)
5837  {
5838  names[b*R->isLPring]=omStrDup(v);
5839  for(int i=R->isLPring-1;i>0;i--)
5840  names[i+b*R->isLPring]=R->names[i-1+b*r->isLPring];
5841  }
5842  }
5843  else
5844  {
5845  for(int b=0;b<((r->N)/r->isLPring);b++)
5846  {
5847  names[(b+1)*R->isLPring-1]=omStrDup(v);
5848  for(int i=R->isLPring-2;i>=0;i--)
5849  names[i+b*R->isLPring]=R->names[i+b*r->isLPring];
5850  }
5851  }
5852  }
5853  else
5854  #endif
5855  {
5856  R->N++;
5857  names=(char**)omAlloc(R->N*sizeof(char_ptr));
5858  if (left)
5859  {
5860  names[0]=omStrDup(v);
5861  for(int i=R->N-1;i>0;i--) names[i]=R->names[i-1];
5862  }
5863  else
5864  {
5865  names[R->N-1]=omStrDup(v);
5866  for(int i=R->N-2;i>=0;i--) names[i]=R->names[i];
5867  }
5868  }
5869  omFreeSize(R->names,r->N*sizeof(char_ptr));
5870  R->names=names;
5871  R->block1[p]=R->N;
5872  rComplete(R);
5873  return R;
5874 }
CanonicalForm b
Definition: cfModGcd.cc:4103

◆ rRing_has_CompLastBlock()

BOOLEAN rRing_has_CompLastBlock ( const ring  r)

Definition at line 5185 of file ring.cc.

5186 {
5187  assume(r != NULL);
5188  int lb = rBlocks(r) - 2;
5189  return (r->order[lb] == ringorder_c || r->order[lb] == ringorder_C);
5190 }

◆ rRing_ord_pure_dp()

BOOLEAN rRing_ord_pure_dp ( const ring  r)

Definition at line 5192 of file ring.cc.

5193 {
5194  if ((r->order[0]==ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5195  return TRUE;
5196  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5197  && ((r->order[1]==ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5198  return TRUE;
5199  return FALSE;
5200 }

◆ rRing_ord_pure_Dp()

BOOLEAN rRing_ord_pure_Dp ( const ring  r)

Definition at line 5202 of file ring.cc.

5203 {
5204  if ((r->order[0]==ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5205  return TRUE;
5206  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5207  && ((r->order[1]==ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5208  return TRUE;
5209  return FALSE;
5210 }

◆ rRing_ord_pure_lp()

BOOLEAN rRing_ord_pure_lp ( const ring  r)

Definition at line 5212 of file ring.cc.

5213 {
5214  if ((r->order[0]==ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5215  return TRUE;
5216  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5217  && ((r->order[1]==ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5218  return TRUE;
5219  return FALSE;
5220 }

◆ 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 5032 of file ring.cc.

5033 {
5034  // Put the reference set F into the ring -ordering -recor
5035 
5036  if (r->typ==NULL)
5037  {
5038  dReportError("Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5039  return FALSE;
5040  }
5041 
5042 
5043  int pos = rGetISPos(p, r);
5044 
5045  if( pos == -1 )
5046  {
5047  dReportError("Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5048  return FALSE;
5049  }
5050 
5051 #if MYTEST
5052  if( i != r->typ[pos].data.is.limit )
5053  Print("Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
5054 #endif
5055 
5056  const ideal FF = idrHeadR(F, r, r); // id_Copy(F, r); // ???
5057 
5058 
5059  if( r->typ[pos].data.is.F != NULL)
5060  {
5061 #if MYTEST
5062  PrintS("Deleting old reference set F... \n"); // idShow(r->typ[pos].data.is.F, r); PrintLn();
5063 #endif
5064  id_Delete(&r->typ[pos].data.is.F, r);
5065  r->typ[pos].data.is.F = NULL;
5066  }
5067 
5068  assume(r->typ[pos].data.is.F == NULL);
5069 
5070  r->typ[pos].data.is.F = FF; // F is owened by ring now! TODO: delete at the end!
5071 
5072  r->typ[pos].data.is.limit = i; // First induced component
5073 
5074 #if MYTEST
5075  PrintS("New reference set FF : \n"); idShow(FF, r, r, 1); PrintLn();
5076 #endif
5077 
5078  return TRUE;
5079 }
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:5000
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
Definition: simpleideals.cc:57

◆ rSetSyzComp()

void rSetSyzComp ( int  k,
const ring  r 
)

Definition at line 5086 of file ring.cc.

5087 {
5088  if(k < 0)
5089  {
5090  dReportError("rSetSyzComp with negative limit!");
5091  return;
5092  }
5093 
5094  assume( k >= 0 );
5095  if (TEST_OPT_PROT) Print("{%d}", k);
5096  if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz))
5097  {
5098  r->block0[0]=r->block1[0] = k;
5099  if( k == r->typ[0].data.syz.limit )
5100  return; // nothing to do
5101 
5102  int i;
5103  if (r->typ[0].data.syz.limit == 0)
5104  {
5105  r->typ[0].data.syz.syz_index = (int*) omAlloc0((k+1)*sizeof(int));
5106  r->typ[0].data.syz.syz_index[0] = 0;
5107  r->typ[0].data.syz.curr_index = 1;
5108  }
5109  else
5110  {
5111  r->typ[0].data.syz.syz_index = (int*)
5112  omReallocSize(r->typ[0].data.syz.syz_index,
5113  (r->typ[0].data.syz.limit+1)*sizeof(int),
5114  (k+1)*sizeof(int));
5115  }
5116  for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
5117  {
5118  r->typ[0].data.syz.syz_index[i] =
5119  r->typ[0].data.syz.curr_index;
5120  }
5121  if(k < r->typ[0].data.syz.limit) // ?
5122  {
5123 #ifndef SING_NDEBUG
5124  Warn("rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
5125 #endif
5126  r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[k];
5127  }
5128 
5129 
5130  r->typ[0].data.syz.limit = k;
5131  r->typ[0].data.syz.curr_index++;
5132  }
5133  else if(
5134  (r->typ!=NULL) &&
5135  (r->typ[0].ord_typ==ro_isTemp)
5136  )
5137  {
5138 // (r->typ[currRing->typ[0].data.isTemp.suffixpos].data.is.limit == k)
5139 #ifndef SING_NDEBUG
5140  Warn("rSetSyzComp(%d) in an IS ring! Be careful!", k);
5141 #endif
5142  }
5143  else if (r->order[0]==ringorder_s)
5144  {
5145  r->block0[0] = r->block1[0] = k;
5146  }
5147  else if (r->order[0]!=ringorder_c)
5148  {
5149  dReportError("syzcomp in incompatible ring");
5150  }
5151 #ifdef PDEBUG
5152  EXTERN_VAR int pDBsyzComp;
5153  pDBsyzComp=k;
5154 #endif
5155 }
#define EXTERN_VAR
Definition: globaldefs.h:6
#define TEST_OPT_PROT
Definition: options.h:104
VAR int pDBsyzComp
Definition: ring.cc:5082

◆ rSetWeightVec()

void rSetWeightVec ( ring  r,
int64 wv 
)

Definition at line 5232 of file ring.cc.

5233 {
5234  assume(r!=NULL);
5235  assume(r->OrdSize>0);
5236  assume(r->typ[0].ord_typ==ro_wp64);
5237  memcpy(r->typ[0].data.wp64.weights64,wv,r->N*sizeof(int64));
5238 }

◆ 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 * rVarStr(ring r)
Definition: ring.cc:623
char * rOrdStr(ring r)
Definition: ring.cc:521
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition: ring.cc:647

◆ 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:837

◆ 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 
752  ip_sring tmpR;
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)
940 #ifdef HAVE_PLURAL
941  && !rIsPluralRing(r1) && !rIsPluralRing(r2)
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
963 #ifdef HAVE_PLURAL
964  && !rIsPluralRing(r1) && !rIsPluralRing(r2)
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);
1181  sum=(ring)omAllocBin(sip_sring_bin);
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 
1196  BOOLEAN R1_is_nc = rIsPluralRing(r1);
1197  BOOLEAN R2_is_nc = rIsPluralRing(r2);
1198 
1199  if ( (R1_is_nc) || (R2_is_nc))
1200  {
1201  ring R1 = nc_rCreateNCcomm_rCopy(r1);
1202  assume( rIsPluralRing(R1) );
1203 
1204 #if 0
1205 #ifdef RDEBUG
1206  rWrite(R1);
1207  rDebugPrint(R1);
1208 #endif
1209 #endif
1210  ring R2 = nc_rCreateNCcomm_rCopy(r2);
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)
1266  MATELEM(D,i,j) = p_PermPoly(MATELEM(D1,i,j), perm1, R1, sum, nMap1, par_perm1, rPar(R1));
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);
1279  MATELEM(C,rVar(R1)+i,rVar(R1)+j) = p_PermPoly(MATELEM(C2,i,j),perm2,R2,sum, nMap2,par_perm2,rPar(R2));
1280 
1281  if (MATELEM(D2,i,j) != NULL)
1282  MATELEM(D,rVar(R1)+i,rVar(R1)+j) = p_PermPoly(MATELEM(D2,i,j),perm2,R2,sum, nMap2,par_perm2,rPar(R2));
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);
1297  rDebugPrint(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);
1311  if (par_perm1!=NULL) omFree((ADDRESS)par_perm1);
1312  if (par_perm2!=NULL) omFree((ADDRESS)par_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 
1349  omFree((ADDRESS)perm1);
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 
1372  omFree((ADDRESS)perm2);
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) )
1392  nc_SetupQuotient( 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
STATIC_VAR jList * Q
Definition: janet.cc:30
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)
Definition: omAllocDecl.h:205
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
Definition: simpleideals.cc:35
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
Definition: ring.h:248
n_Procs_s * cf
Definition: ring.h:368
int * block0
Definition: ring.h:254
short N
Definition: ring.h:303
int * block1
Definition: ring.h:255
rRingOrder_t * order
Definition: ring.h:253
int ** wvhdl
Definition: ring.h:257
unsigned long bitmask
Definition: ring.h:350
char ** names
Definition: ring.h:258
short OrdSgn
Definition: ring.h:305

◆ 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)
Definition: mpr_complex.cc:327

◆ rUnComplete()

void rUnComplete ( ring  r)

Definition at line 3965 of file ring.cc.

3966 {
3967  if (r == NULL) return;
3968  if (r->VarOffset != NULL)
3969  {
3970  if (r->OrdSize!=0 && r->typ != NULL)
3971  {
3972  for(int i = 0; i < r->OrdSize; i++)
3973  if( r->typ[i].ord_typ == ro_is) // Search for suffixes! (prefix have the same VarOffset)
3974  {
3975  id_Delete(&r->typ[i].data.is.F, r);
3976 
3977  if( r->typ[i].data.is.pVarOffset != NULL )
3978  {
3979  omFreeSize((ADDRESS)r->typ[i].data.is.pVarOffset, (r->N +1)*sizeof(int));
3980  }
3981  }
3982  else if (r->typ[i].ord_typ == ro_syz)
3983  {
3984  if(r->typ[i].data.syz.limit > 0)
3985  omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*sizeof(int));
3986  }
3987  else if (r->typ[i].ord_typ == ro_syzcomp)
3988  {
3989  assume( r->typ[i].data.syzcomp.ShiftedComponents == NULL );
3990  assume( r->typ[i].data.syzcomp.Components == NULL );
3991 // WarnS( "rUnComplete : ord_typ == ro_syzcomp was unhandled!!! Possibly memory leak!!!" );
3992 #ifndef SING_NDEBUG
3993 // assume(0);
3994 #endif
3995  }
3996 
3997  omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord)); r->typ = NULL;
3998  }
3999 
4000  if (r->PolyBin != NULL)
4001  omUnGetSpecBin(&(r->PolyBin));
4002 
4003  omFreeSize((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
4004  r->VarOffset=NULL;
4005 
4006  if (r->ordsgn != NULL && r->CmpL_Size != 0)
4007  {
4008  omFreeSize((ADDRESS)r->ordsgn,r->ExpL_Size*sizeof(long));
4009  r->ordsgn=NULL;
4010  }
4011  if (r->p_Procs != NULL)
4012  {
4013  omFreeSize(r->p_Procs, sizeof(p_Procs_s));
4014  r->p_Procs=NULL;
4015  }
4016  omfreeSize(r->VarL_Offset, r->VarL_Size*sizeof(int));
4017  r->VarL_Offset=NULL;
4018  }
4019  if (r->NegWeightL_Offset!=NULL)
4020  {
4021  omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*sizeof(int));
4022  r->NegWeightL_Offset=NULL;
4023  }
4024 }
#define omfreeSize(addr, size)
Definition: omAllocDecl.h:236
#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
263  n_CoeffWrite(C, details);
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:834
#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 828 of file ring.h.