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

Go to the source code of this file.

Data Structures

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

Macros

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

Typedefs

typedef idrecidhdl
 
typedef struct p_Procs_s p_Procs_s
 
typedef kBucketkBucket_pt
 
typedef long(* pLDegProc) (poly p, int *length, ring r)
 
typedef long(* pFDegProc) (poly p, ring r)
 
typedef void(* p_SetmProc) (poly p, const ring r)
 
typedef poly(* pShallowCopyDeleteProc) (poly s_p, ring source_r, ring dest_r, omBin dest_bin)
 returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == dest_r->N and that orderings are the same 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 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 23 of file ring.h.

◆ p_SetmProc

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

Definition at line 39 of file ring.h.

◆ pFDegProc

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

Definition at line 38 of file ring.h.

◆ pLDegProc

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

Definition at line 37 of file ring.h.

◆ pShallowCopyDeleteProc

typedef poly(* pShallowCopyDeleteProc) (poly s_p, ring source_r, ring dest_r, omBin dest_bin)

returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == dest_r->N and that orderings are the same

Definition at line 44 of file ring.h.

Enumeration Type Documentation

◆ ro_typ

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)
63}
@ ro_wp64
Definition: ring.h:55
@ ro_syz
Definition: ring.h:60
@ ro_cp
Definition: ring.h:58
@ ro_dp
Definition: ring.h:52
@ ro_is
Definition: ring.h:61
@ ro_wp_neg
Definition: ring.h:56
@ ro_wp
Definition: ring.h:53
@ ro_isTemp
Definition: ring.h:61
@ ro_am
Definition: ring.h:54
@ ro_none
Definition: ring.h:62
@ ro_syzcomp
Definition: ring.h:59

◆ rOrderType_t

Enumerator
rOrderType_General 

non-simple ordering as specified by currRing

rOrderType_CompExp 

simple ordering, component has priority

rOrderType_ExpComp 

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

rOrderType_Exp 

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

rOrderType_Syz 

syzygy ordering

rOrderType_Schreyer 

Schreyer ordering.

rOrderType_Syz2dpc 

syzcomp2dpc

rOrderType_ExpNoComp 

simple ordering, differences in component are not considered

Definition at line 97 of file ring.h.

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

◆ rRingOrder_t

order stuff

Enumerator
ringorder_no 
ringorder_a 
ringorder_a64 

for int64 weights

ringorder_c 
ringorder_C 
ringorder_M 
ringorder_S 

S?

ringorder_s 

s?

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

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

ringorder_rs 

opposite of ls

ringorder_IS 

Induced (Schreyer) ordering.

ringorder_unspec 

Definition at line 67 of file ring.h.

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

Function Documentation

◆ n_IsParam()

int n_IsParam ( const number  m,
const ring  r 
)

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

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

Definition at line 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 {
3422 si_opt_1 &= ~ TEST_RINGDEP_OPTS;
3423 si_opt_1 |= r->options;
3424 }
3425}
VAR unsigned si_opt_1
Definition: options.c:5

◆ r_IsRingVar()

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

Definition at line 212 of file ring.cc.

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

◆ rAssure_C_dp()

ring rAssure_C_dp ( const ring  r)

Definition at line 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));
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);
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);
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 "" )
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:4512
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
Definition: ring.cc:1799
#define IDELEMS(i)
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 {
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
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 {
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:4130
#define rOppVar(R, I)
Definition: ring.cc:5278
const char * rSimpleOrdStr(int ord)
Definition: ring.cc:77
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}
#define StringAppend
Definition: emacs.cc:79
const CanonicalForm & w
Definition: facAbsFact.cc:51
for(j=0;j< factors.length();j++)
Definition: facHensel.cc:129
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
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 * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition: ring.cc:647
char * rOrdStr(ring r)
Definition: ring.cc:521
char * rVarStr(ring r)
Definition: ring.cc:623

◆ rSum()

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

Definition at line 1402 of file ring.cc.

1403{
1404 if ((r1==NULL)||(r2==NULL)
1405 ||(r1->cf==NULL)||(r2->cf==NULL))
1406 return -1;
1407 if (r1==r2)
1408 {
1409 sum=r1;
1410 rIncRefCnt(r1);
1411 return 0;
1412 }
1413 return rSumInternal(r1,r2,sum,TRUE,FALSE);
1414}
int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering,...
Definition: ring.cc:749
static ring rIncRefCnt(ring r)
Definition: ring.h: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
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
#define Q
Definition: sirandom.c:26
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:827
#define p_GetCoeff(p, r)
Definition: monomials.h:50
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:332
static BOOLEAN rShortOut(const ring r)
Definition: ring.h:581
static BOOLEAN rCanShortOut(const ring r)
Definition: ring.h:586
ideal SCAQuotient(const ring r)
Definition: sca.h:10

Variable Documentation

◆ sip_sring_bin

EXTERN_VAR omBin sip_sring_bin

Definition at line 828 of file ring.h.