Loading...
Searching...
No Matches
ring.cc File Reference
`#include <cmath>`
`#include "misc/auxiliary.h"`
`#include "misc/mylimits.h"`
`#include "misc/options.h"`
`#include "misc/int64vec.h"`
`#include "coeffs/numbers.h"`
`#include "coeffs/coeffs.h"`
`#include "polys/monomials/p_polys.h"`
`#include "polys/simpleideals.h"`
`#include "polys/monomials/ring.h"`
`#include "polys/monomials/maps.h"`
`#include "polys/prCopy.h"`
`#include "polys/templates/p_Procs.h"`
`#include "polys/matpol.h"`
`#include "polys/nc/nc.h"`
`#include "polys/nc/sca.h"`
`#include "ext_fields/algext.h"`
`#include "ext_fields/transext.h"`
`#include <ctype.h>`

Go to the source code of this file.

## Macros

#define | BITS_PER_LONG 8*SIZEOF_LONG
#define | MYTEST 0
#define | pFDeg_CASE(A)
#define | rOppVar(R, I)

## Typedefs

typedef char * | char_ptr

## Functions

const char * | rSimpleOrdStr (int ord)
void | rDelete (ring r)
| unconditionally deletes fields in r
static void | rSetVarL (ring r)
| set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
static unsigned long | rGetDivMask (int bits)
| get r->divmask depending on bits per exponent
static void | rRightAdjustVarOffset (ring r)
| right-adjust r->VarOffset
static void | rOptimizeLDeg (ring r)
ring | rDefault (const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
ring | rDefault (int ch, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl)
ring | rDefault (const coeffs cf, int N, char **n, const rRingOrder_t o)
ring | rDefault (int ch, int N, char **n)
BOOLEAN | rCheckIV (const intvec *iv)
int | rTypeOfMatrixOrder (const intvec *order)
int | r_IsRingVar (const char *n, char **names, int N)
void | rWrite (ring r, BOOLEAN details)
rRingOrder_t | rOrderName (char *ordername)
char * | rOrdStr (ring r)
char * | rVarStr (ring r)
char * | rCharStr (const ring r)
| TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
char * | rParStr (ring r)
char * | rString (ring r)
int | rChar (ring r)
ring | nc_rCreateNCcomm_rCopy (ring r)
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
int | rSum (ring r1, ring r2, ring &sum)
ring | rCopy0 (const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
ring | rCopy0AndAddA (const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
ring | rCopy (ring r)
BOOLEAN | rEqual (ring r1, ring r2, BOOLEAN qr)
| returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise, if qr == 1, then qrideal equality is tested, as well
BOOLEAN | rSamePolyRep (ring r1, ring r2)
| returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analogue to rEqual but not so strict
rOrderType_t | rGetOrderType (ring r)
BOOLEAN | rHas_c_Ordering (const ring r)
BOOLEAN | rHasSimpleOrder (const ring r)
BOOLEAN | rHasBlockOrder (const ring r)
BOOLEAN | rHasSimpleLexOrder (const ring r)
| returns TRUE, if simple lp or ls ordering
BOOLEAN | rOrder_is_DegOrdering (const rRingOrder_t order)
BOOLEAN | rOrder_is_WeightedOrdering (rRingOrder_t order)
BOOLEAN | rHasSimpleOrderAA (ring r)
BOOLEAN | rOrd_SetCompRequiresSetm (const ring r)
| return TRUE if p_SetComp requires p_Setm
BOOLEAN | rOrd_is_Totaldegree_Ordering (const ring r)
BOOLEAN | rOrd_is_dp (const ring r)
BOOLEAN | rOrd_is_ds (const ring r)
BOOLEAN | rOrd_is_Ds (const ring r)
BOOLEAN | rOrd_is_WeightedDegree_Ordering (const ring r)
BOOLEAN | rDBTest (ring r, const char *fn, const int l)
static void | rO_Align (int &place, int &bitplace)
static void | rO_TDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
static void | rO_TDegree_neg (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
static void | rO_WDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
static void | rO_WMDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
static void | rO_WDegree64 (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
static void | rO_WDegree_neg (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
static void | rO_LexVars (int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
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)
static void | rO_Syzcomp (int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
static void | rO_Syz (int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
static void | rO_ISPrefix (int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
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)
static unsigned long | rGetExpSize (unsigned long bitmask, int &bits)
unsigned long | rGetExpSize (unsigned long bitmask, int &bits, int N)
ring | rModifyRing (ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
ring | rModifyRing_Wp (ring r, int *weights)
| construct Wp, C ring
ring | rModifyRing_Simple (ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
void | rKillModifiedRing (ring r)
void | rKillModified_Wp_Ring (ring r)
static void | rSetOutParams (ring r)
static void | rSetFirstWv (ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
static void | rSetDegStuff (ring r)
static void | rSetNegWeight (ring r)
static void | rSetOption (ring r)
static void | rCheckOrdSgn (ring r, int i)
void | p_SetGlobals (const ring r, BOOLEAN complete)
| set all properties of a new ring - also called by rComplete
static int | sign (int x)
BOOLEAN | rOrd_is_MixedDegree_Ordering (ring r)
BOOLEAN | rComplete (ring r, int force)
| this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffset), unless they already exist with force == 1, new fields are always created (overwritten), even if they exist
void | rUnComplete (ring r)
void | rDebugPrint (const ring r)
void | p_DebugPrint (poly p, const ring r)
static void | m_DebugPrint (const poly p, const ring R)
| debug-print monomial poly/vector p, assuming that it lives in the ring R
static void | rNChangeSComps (int *currComponents, long *currShiftedComponents, ring r)
static void | rNGetSComps (int **currComponents, long **currShiftedComponents, ring r)
static void | rDBChangeSComps (int *currComponents, long *currShiftedComponents, int length, ring r)
static void | rDBGetSComps (int **currComponents, long **currShiftedComponents, int *length, ring r)
void | rChangeSComps (int *currComponents, long *currShiftedComponents, int length, ring r)
void | rGetSComps (int **currComponents, long **currShiftedComponents, int *length, ring r)
ring | rAssure_SyzOrder (const ring r, BOOLEAN complete)
ring | rAssure_SyzComp (const ring r, BOOLEAN complete)
ring | rAssure_TDeg (ring r, int &pos)
ring | rAssure_HasComp (const ring r)
ring | rAssure_CompLastBlock (ring r, BOOLEAN complete)
| makes sure that c/C ordering is last ordering
ring | rAssure_SyzComp_CompLastBlock (const ring r)
| makes sure that c/C ordering is last ordering and SyzIndex is first
static ring | rAssure_Global (rRingOrder_t b1, rRingOrder_t b2, const ring r)
ring | rAssure_Wp_C (const ring r, intvec *w)
ring | rAssure_InducedSchreyerOrdering (const ring r, BOOLEAN complete, int sgn)
ring | rAssure_dp_S (const ring r)
ring | rAssure_dp_C (const ring r)
ring | rAssure_Dp_C (const ring r)
ring | rAssure_C_dp (const ring r)
ring | rAssure_c_dp (const ring r)
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! p - starts with 0!
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, we will DO a copy! We will use it AS IS! returns true is everything was alright!
void | rSetSyzComp (int k, const ring r)
int | rGetMaxSyzComp (int i, const ring r)
| return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
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)
int64 * | rGetWeightVec (const ring r)
void | rSetWeightVec (ring r, int64 *wv)
static int | rRealloc1 (ring r, int size, int pos)
static void | rOppWeight (int *w, int l)
ring | rOpposite (ring src)
ring | rEnvelope (ring R)
BOOLEAN | nc_rComplete (const ring src, ring dest, bool bSetupQuotient)
poly | rGetVar (const int varIndex, const ring r)
int | n_IsParam (const number m, const ring r)
| TODO: rewrite somehow...
ring | rPlusVar (const ring r, char *v, int left)
| K[x],"y" -> K[x,y] resp. K[y,x].
ring | rMinusVar (const ring r, char *v)
| undo rPlusVar

## Variables

VAR omBin | sip_sring_bin = omGetSpecBin(sizeof(ip_sring))
VAR omBin | char_ptr_bin = omGetSpecBin(sizeof(char_ptr))
static const char *const | ringorder_name []
VAR int | pDBsyzComp =0

## Macro Definition Documentation

## BITS_PER_LONG

#define BITS_PER_LONG 8*SIZEOF_LONG

Definition at line 40 of file ring.cc.

## MYTEST

#define MYTEST 0

Definition at line 2513 of file ring.cc.

## pFDeg_CASE

#define pFDeg_CASE | ( |  | A | ) |

Value:
if(r->pFDeg == A) PrintS( "" #A "" )
PrintS
void PrintS(const char *s)
Definition reporter.cc:288
A
#define A
Definition sirandom.c:24

## rOppVar

#define rOppVar | ( |  | R,
|  |  | I )

Value:
(rVar(R)+1-I)
rVar
static short rVar(const ring r)
define rVar(r) (r->N)
Definition ring.h:598
R
#define R
Definition sirandom.c:27

Definition at line 5422 of file ring.cc.

## Typedef Documentation

## char_ptr

typedef char* char_ptr

Definition at line 42 of file ring.cc.

## Function Documentation

## m_DebugPrint()

void m_DebugPrint | ( | const poly | p,
|  | const ring | R )

inline static

debug-print monomial poly/vector p, assuming that it lives in the ring R

Definition at line 4442 of file ring.cc.

{
Print("\nexp[0..%d]\n", R->ExpL_Size - 1);
for(int i = 0; i < R->ExpL_Size; i++)
Print("%09lx ", p->exp[i]);
PrintLn();
Print("v0:%9ld ", p_GetComp(p, R));
for(int i = 1; i <= R->N; i++) Print(" v%d:%5ld",i, p_GetExp(p, i, R));
PrintLn();
}
i
int i
Definition cfEzgcd.cc:132
p
int p
Definition cfModGcd.cc:4086
Print
#define Print
Definition emacs.cc:80
p_GetComp
#define p_GetComp(p, r)
Definition monomials.h:64
p_GetExp
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:471
PrintLn
void PrintLn()
Definition reporter.cc:314

## n_IsParam()

int n_IsParam | ( | const number | m,
|  | const ring | r )

TODO: rewrite somehow...

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

Definition at line 5921 of file ring.cc.

{
assume(r != NULL);
const coeffs C = r->cf;
assume(C != NULL);
assume( nCoeff_is_Extension(C) );
const n_coeffType _filed_type = getCoeffType(C);
if(( _filed_type == n_algExt )||( _filed_type == n_polyExt ))
return naIsParam(m, C);
if( _filed_type == n_transExt )
return ntIsParam(m, C);
Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C));
return 0;
}
naIsParam
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition algext.cc:1151
m
int m
Definition cfEzgcd.cc:128
nCoeff_is_Extension
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition coeffs.h:841
n_coeffType
n_coeffType
Definition coeffs.h:27
n_polyExt
@ n_polyExt
used to represent polys as coefficients
Definition coeffs.h:34
n_algExt
@ 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
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition coeffs.h:431
assume
#define assume(x)
Definition mod2.h:389
coeffs
The main handler for Singular numbers which are suitable for Singular polynomials.
NULL
#define NULL
Definition omList.c:12
Werror
void Werror(const char *fmt,...)
Definition reporter.cc:189
ntIsParam
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition transext.cc:2308

## nc_rComplete()

BOOLEAN nc_rComplete | ( | const ring | src,
|  | ring | dest,
|  | bool | bSetupQuotient )

Definition at line 5833 of file ring.cc.

{
// NOTE: Originally used only by idElimination to transfer NC structure to dest
// ring created by dirty hack (without nc_CallPlural)
rTest(src);
assume(!rIsPluralRing(dest)); // destination must be a newly constructed commutative ring
if (!rIsPluralRing(src))
{
return FALSE;
}
const int N = dest->N;
assume(src->N == N);
// ring save = currRing;
// if (dest != save)
// rChangeCurrRing(dest);
const ring srcBase = src;
assume( n_SetMap(srcBase->cf,dest->cf) == n_SetMap(dest->cf,dest->cf) ); // currRing is important here!
matrix C = mpNew(N,N); // ring independent
matrix D = mpNew(N,N);
matrix C0 = src->GetNC()->C;
matrix D0 = src->GetNC()->D;
// map C and D into dest
for (int i = 1; i < N; i++)
{
for (int j = i + 1; j <= N; j++)
{
const number n = n_Copy(p_GetCoeff(MATELEM(C0,i,j), srcBase), srcBase->cf); // src, mapping for coeffs into currRing = dest!
const poly p = p_NSet(n, dest);
MATELEM(C,i,j) = p;
if (MATELEM(D0,i,j) != NULL)
MATELEM(D,i,j) = prCopyR(MATELEM(D0,i,j), srcBase, dest); // ?
}
}
/* One must test C and D _only_ in r->GetNC()->basering!!! not in r!!! */
id_Test((ideal)C, dest);
id_Test((ideal)D, dest);
if (nc_CallPlural(C, D, NULL, NULL, dest, bSetupQuotient, false, true, dest)) // also takes care about quotient ideal
{
//WarnS("Error transferring non-commutative structure");
// error message should be in the interpreter interface
mp_Delete(&C, dest);
mp_Delete(&D, dest);
// if (currRing != save)
// rChangeCurrRing(save);
return TRUE;
}
// mp_Delete(&C, dest); // used by nc_CallPlural!
// mp_Delete(&D, dest);
// if (dest != save)
// rChangeCurrRing(save);
assume(rIsPluralRing(dest));
return FALSE;
}
TRUE
#define TRUE
Definition auxiliary.h:101
FALSE
#define FALSE
Definition auxiliary.h:97
N
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:457
n_SetMap
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:703
j
int j
Definition facHensel.cc:110
D
#define D(A)
Definition gentable.cc:128
nc_CallPlural
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:2692
mp_Delete
void mp_Delete(matrix *a, const ring r)
Definition matpol.cc:874
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition matpol.cc:37
MATELEM
#define MATELEM(mat, i, j)
1-based access to matrix
Definition matpol.h:29
matrix
ip_smatrix * matrix
Definition matpol.h:43
p_GetCoeff
#define p_GetCoeff(p, r)
Definition monomials.h:50
p_NSet
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition p_polys.cc:1474
prCopyR
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition prCopy.cc:34
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406
rTest
#define rTest(r)
Definition ring.h:794
id_Test
#define id_Test(A, lR)
Definition simpleideals.h:89

## nc_rCreateNCcomm_rCopy()

ring nc_rCreateNCcomm_rCopy | ( | ring | r | ) |

Definition at line 725 of file ring.cc.

{
r = rCopy(r);
if (rIsPluralRing(r))
return r;
matrix C = mpNew(r->N,r->N); // ring-independent!?!
matrix D = mpNew(r->N,r->N);
for(int i=1; i<r->N; i++)
for(int j=i+1; j<=r->N; j++)
MATELEM(C,i,j) = p_One( r);
if (nc_CallPlural(C, D, NULL, NULL, r, false, true, false, r/*??currRing??*/, TRUE)) // TODO: what about quotient ideal?
WarnS("Error initializing multiplication!"); // No reaction!???
return r;
}
WarnS
#define WarnS
Definition emacs.cc:78
p_One
poly p_One(const ring r)
Definition p_polys.cc:1314
rCopy
ring rCopy(ring r)
Definition ring.cc:1737

## p_DebugPrint()

void p_DebugPrint | ( | poly | p,
|  | const ring | r )

Definition at line 4419 of file ring.cc.

{
int i,j;
p_Write(p,r);
j=2;
while(p!=NULL)
{
Print("\nexp[0..%d]\n",r->ExpL_Size-1);
for(i=0;i<r->ExpL_Size;i++)
Print("%ld ",p->exp[i]);
PrintLn();
Print("v0:%ld ",p_GetComp(p, r));
for(i=1;i<=r->N;i++) Print(" v%d:%ld",i,p_GetExp(p,i, r));
PrintLn();
pIter(p);
j--;
if (j==0) { PrintS("...\n"); break; }
}
}
pIter
#define pIter(p)
Definition monomials.h:37
p_Write
void p_Write(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:342

## p_SetGlobals()

void p_SetGlobals | ( | const ring | r,
|  | BOOLEAN | complete )

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

Definition at line 3494 of file ring.cc.

{
r->pLexOrder=r->LexOrder;
if (complete)
{
si_opt_1 &= ~ TEST_RINGDEP_OPTS;
si_opt_1 |= r->options;
}
}
si_opt_1
VAR unsigned si_opt_1
Definition options.c:5

## r_IsRingVar()

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

Definition at line 213 of file ring.cc.

{
if (names!=NULL)
{
for (int i=0; i<N; i++)
{
if (names[i]==NULL) return -1;
if (strcmp(n,names[i]) == 0) return (int)i;
}
}
return -1;
}

## rAssure_C_dp()

ring rAssure_C_dp | ( | const ring | r | ) |

Definition at line 5129 of file ring.cc.

{
return rAssure_Global(ringorder_C, ringorder_dp, r);
}
rAssure_Global
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
Definition ring.cc:4896
ringorder_C
@ ringorder_C
Definition ring.h:74
ringorder_dp
@ ringorder_dp
Definition ring.h:79

## rAssure_c_dp()

ring rAssure_c_dp | ( | const ring | r | ) |

Definition at line 5134 of file ring.cc.

{
return rAssure_Global(ringorder_c, ringorder_dp, r);
}
ringorder_c
@ ringorder_c
Definition ring.h:73

## rAssure_CompLastBlock()

ring rAssure_CompLastBlock | ( | ring | r,
|  | BOOLEAN | complete )

makes sure that c/C ordering is last ordering

Definition at line 4786 of file ring.cc.

{
int last_block = rBlocks(r) - 2;
if (r->order[last_block] != ringorder_c &&
r->order[last_block] != ringorder_C)
{
int c_pos = 0;
int i;
for (i=0; i< last_block; i++)
{
if (r->order[i] == ringorder_c || r->order[i] == ringorder_C)
{
c_pos = i;
break;
}
}
if (c_pos != -1)
{
ring new_r = rCopy0(r, FALSE, TRUE);
for (i=c_pos+1; i<=last_block; i++)
{
new_r->order[i-1] = new_r->order[i];
new_r->block0[i-1] = new_r->block0[i];
new_r->block1[i-1] = new_r->block1[i];
new_r->wvhdl[i-1] = new_r->wvhdl[i];
}
new_r->order[last_block] = r->order[c_pos];
new_r->block0[last_block] = r->block0[c_pos];
new_r->block1[last_block] = r->block1[c_pos];
new_r->wvhdl[last_block] = r->wvhdl[c_pos];
if (complete)
{
rComplete(new_r, 1);
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, new_r, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
#endif
}
}
assume(rIsPluralRing(r) == rIsPluralRing(new_r));
#endif
}
return new_r;
}
}
return r;
}
rComplete
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:3527
nc_rComplete
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition ring.cc:5833
rCopy0
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition ring.cc:1427
rBlocks
static int rBlocks(const ring r)
Definition ring.h:574

## rAssure_Dp_C()

ring rAssure_Dp_C | ( | const ring | r | ) |

Definition at line 5124 of file ring.cc.

{
return rAssure_Global(ringorder_Dp, ringorder_C, r);
}
ringorder_Dp
@ ringorder_Dp
Definition ring.h:81

## rAssure_dp_C()

ring rAssure_dp_C | ( | const ring | r | ) |

Definition at line 5119 of file ring.cc.

{
return rAssure_Global(ringorder_dp, ringorder_C, r);
}

## rAssure_dp_S()

ring rAssure_dp_S | ( | const ring | r | ) |

Definition at line 5114 of file ring.cc.

{
return rAssure_Global(ringorder_dp, ringorder_S, r);
}
ringorder_S
@ ringorder_S
S?
Definition ring.h:76

## rAssure_Global()

ring rAssure_Global | ( | rRingOrder_t | b1,
|  | rRingOrder_t | b2,
|  | const ring | r )

static

Definition at line 4896 of file ring.cc.

{
int r_blocks = rBlocks(r);
assume(b1 == ringorder_c || b1 == ringorder_C ||
b2 == ringorder_c || b2 == ringorder_C ||
b2 == ringorder_S);
if ((r_blocks == 3) &&
(r->order[0] == b1) &&
(r->order[1] == b2) &&
(r->order[2] == 0))
return r;
ring res = rCopy0(r, FALSE, FALSE);
res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
res->block0 = (int*)omAlloc0(3*sizeof(int));
res->block1 = (int*)omAlloc0(3*sizeof(int));
res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
res->order[0] = b1;
res->order[1] = b2;
if (b1 == ringorder_c || b1 == ringorder_C)
{
res->block0[1] = 1;
res->block1[1] = r->N;
}
else
{
res->block0[0] = 1;
res->block1[0] = r->N;
}
rComplete(res, 1);
if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, res, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete");
#endif
}
}
#endif
// rChangeCurrRing(res);
return res;
}
res
CanonicalForm res
Definition facAbsFact.cc:60
omAlloc0
#define omAlloc0(size)
Definition omAllocDecl.h:211
idrCopyR_NoSort
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition prCopy.cc:205
rRingOrder_t
rRingOrder_t
order stuff
Definition ring.h:69

## rAssure_HasComp()

ring rAssure_HasComp | ( | const ring | r | ) |

Definition at line 4717 of file ring.cc.

{
int last_block;
int i=0;
do
{
if (r->order[i] == ringorder_c ||
r->order[i] == ringorder_C) return r;
if (r->order[i] == 0)
break;
i++;
} while (1);
//WarnS("re-creating ring with comps");
last_block=i-1;
ring new_r = rCopy0(r, FALSE, FALSE);
i+=2;
new_r->wvhdl=(int **)omAlloc0(i * sizeof(int *));
new_r->order = (rRingOrder_t *) omAlloc0(i * sizeof(rRingOrder_t));
new_r->block0 = (int *) omAlloc0(i * sizeof(int));
new_r->block1 = (int *) omAlloc0(i * sizeof(int));
memcpy(new_r->order,r->order,(i-1) * sizeof(rRingOrder_t));
memcpy(new_r->block0,r->block0,(i-1) * sizeof(int));
memcpy(new_r->block1,r->block1,(i-1) * sizeof(int));
for (int j=0; j<=last_block; j++)
{
if (r->wvhdl[j]!=NULL)
{
#ifdef HAVE_OMALLOC
new_r->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
#else
{
int l=r->block1[j]-r->block0[j]+1;
if (r->order[j]==ringorder_a64) l*=2;
else if (r->order[j]==ringorder_M) l=l*l;
else if (r->order[j]==ringorder_am)
{
l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
}
new_r->wvhdl[j]=(int*)omalloc(l*sizeof(int));
memcpy(new_r->wvhdl[j],r->wvhdl[j],l*sizeof(int));
}
#endif
}
}
last_block++;
new_r->order[last_block]=ringorder_C;
//new_r->block0[last_block]=0;
//new_r->block1[last_block]=0;
//new_r->wvhdl[last_block]=NULL;
rComplete(new_r, 1);
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, new_r, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
#endif
}
}
assume(rIsPluralRing(r) == rIsPluralRing(new_r));
#endif
return new_r;
}
l
int l
Definition cfEzgcd.cc:100
omalloc
#define omalloc(size)
Definition omAllocDecl.h:228
omMemDup
#define omMemDup(s)
Definition omAllocDecl.h:264
ringorder_am
@ ringorder_am
Definition ring.h:90
ringorder_a64
@ ringorder_a64
for int64 weights
Definition ring.h:72
ringorder_M
@ ringorder_M
Definition ring.h:75

## rAssure_InducedSchreyerOrdering()

ring rAssure_InducedSchreyerOrdering | ( | const ring | r,
|  | BOOLEAN | complete,
|  | int | sgn )

Definition at line 4989 of file ring.cc.

{ // TODO: ???? Add leading Syz-comp ordering here...????
#if MYTEST
Print("rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
rWrite(r);
#ifdef RDEBUG
rDebugPrint(r);
#endif
PrintLn();
#endif
assume((sgn == 1) || (sgn == -1));
ring res=rCopy0(r, FALSE, FALSE); // No qideal & ordering copy.
int n = rBlocks(r); // Including trailing zero!
// Create 2 more blocks for prefix/suffix:
res->order=(rRingOrder_t *)omAlloc0((n+2)*sizeof(rRingOrder_t)); // 0 .. n+1
res->block0=(int *)omAlloc0((n+2)*sizeof(int));
res->block1=(int *)omAlloc0((n+2)*sizeof(int));
int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
// Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
// Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
// new 1st block
int j = 0;
res->order[j] = ringorder_IS; // Prefix
res->block0[j] = res->block1[j] = 0;
// wvhdl[j] = NULL;
j++;
for(int i = 0; (i <= n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
{
res->order [j] = r->order [i];
res->block0[j] = r->block0[i];
res->block1[j] = r->block1[i];
if (r->wvhdl[i] != NULL)
{
#ifdef HAVE_OMALLOC
wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
#else
{
int l=(r->block1[i]-r->block0[i]+1);
if (r->order[i]==ringorder_a64) l*=2;
else if (r->order[i]==ringorder_M) l=l*l;
else if (r->order[i]==ringorder_am)
{
l+=r->wvhdl[i][r->block1[i]-r->block0[i]+1]+1;
}
wvhdl[j]=(int*)omalloc(l*sizeof(int));
memcpy(wvhdl[j],r->wvhdl[i],l*sizeof(int));
}
#endif
} // else wvhdl[j] = NULL;
}
// new last block
res->order [j] = ringorder_IS; // Suffix
res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
// wvhdl[j] = NULL;
j++;
// res->order [j] = 0; // The End!
res->wvhdl = wvhdl;
// j == the last zero block now!
assume(j == (n+1));
assume(res->order[0]==ringorder_IS);
assume(res->order[j-1]==ringorder_IS);
assume(res->order[j]==0);
if (complete)
{
rComplete(res, 1);
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, res, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
#endif
}
}
assume(rIsPluralRing(r) == rIsPluralRing(res));
#endif
#ifdef HAVE_PLURAL
ring old_ring = r;
#endif
if (r->qideal!=NULL)
{
res->qideal= idrCopyR_NoSort(r->qideal, r, res);
assume(id_RankFreeModule(res->qideal, res) == 0);
#ifdef HAVE_PLURAL
if( rIsPluralRing(res) )
if( nc_SetupQuotient(res, r, true) )
{
// WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
}
#endif
assume(id_RankFreeModule(res->qideal, res) == 0);
}
#ifdef HAVE_PLURAL
assume((res->qideal==NULL) == (old_ring->qideal==NULL));
assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
assume(rIsSCA(res) == rIsSCA(old_ring));
assume(ncRingType(res) == ncRingType(old_ring));
#endif
}
return res;
}
sgn
int sgn(const Rational &a)
Definition GMPrat.cc:430
rIsSCA
static bool rIsSCA(const ring r)
Definition nc.h:190
nc_SetupQuotient
bool nc_SetupQuotient(ring rGR, const ring rG=NULL, bool bCopy=false)
Definition old.gring.cc:3385
ncRingType
static nc_type & ncRingType(nc_struct *p)
Definition nc.h:159
rWrite
void rWrite(ring r, BOOLEAN details)
Definition ring.cc:227
rDebugPrint
void rDebugPrint(const ring r)
Definition ring.cc:4214
ringorder_IS
@ ringorder_IS
Induced (Schreyer) ordering.
Definition ring.h:95
id_RankFreeModule
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
Definition simpleideals.cc:992

## rAssure_SyzComp()

ring rAssure_SyzComp | ( | const ring | r,
|  | BOOLEAN | complete )

Definition at line 4527 of file ring.cc.

{
if ( r->order[0] == ringorder_s ) return r;
if ( r->order[0] == ringorder_IS )
{
#ifndef SING_NDEBUG
WarnS("rAssure_SyzComp: input ring has an IS-ordering!");
#endif
// return r;
}
ring res=rCopy0(r, FALSE, FALSE);
int i=rBlocks(r);
int j;
res->order=(rRingOrder_t *)omAlloc((i+1)*sizeof(rRingOrder_t));
res->block0=(int *)omAlloc0((i+1)*sizeof(int));
res->block1=(int *)omAlloc0((i+1)*sizeof(int));
int ** wvhdl =(int **)omAlloc0((i+1)*sizeof(int**));
for(j=i;j>0;j--)
{
res->order[j]=r->order[j-1];
res->block0[j]=r->block0[j-1];
res->block1[j]=r->block1[j-1];
if (r->wvhdl[j-1] != NULL)
{
#ifdef HAVE_OMALLOC
wvhdl[j] = (int*) omMemDup(r->wvhdl[j-1]);
#else
{
int l=r->block1[j-1]-r->block0[j-1]+1;
if (r->order[j-1]==ringorder_a64) l*=2;
else if (r->order[j-1]==ringorder_M) l=l*l;
else if (r->order[j-1]==ringorder_am)
{
l+=r->wvhdl[j-1][r->block1[j-1]-r->block0[j-1]+1]+1;
}
wvhdl[j]=(int*)omalloc(l*sizeof(int));
memcpy(wvhdl[j],r->wvhdl[j-1],l*sizeof(int));
}
#endif
}
}
res->order[0]=ringorder_s;
res->wvhdl = wvhdl;
if (complete)
{
rComplete(res, 1);
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, res, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
#endif
}
}
assume(rIsPluralRing(r) == rIsPluralRing(res));
#endif
#ifdef HAVE_PLURAL
ring old_ring = r;
#endif
if (r->qideal!=NULL)
{
res->qideal= idrCopyR_NoSort(r->qideal, r, res);
assume(id_RankFreeModule(res->qideal, res) == 0);
#ifdef HAVE_PLURAL
if( rIsPluralRing(res) )
{
if( nc_SetupQuotient(res, r, true) )
{
// WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
}
assume(id_RankFreeModule(res->qideal, res) == 0);
}
#endif
}
#ifdef HAVE_PLURAL
assume((res->qideal==NULL) == (old_ring->qideal==NULL));
assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
assume(rIsSCA(res) == rIsSCA(old_ring));
assume(ncRingType(res) == ncRingType(old_ring));
#endif
}
return res;
}
omAlloc
#define omAlloc(size)
Definition omAllocDecl.h:210
ringorder_s
@ ringorder_s
s?
Definition ring.h:77

## 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 4841 of file ring.cc.

{
rTest(r);
ring new_r_1 = rAssure_CompLastBlock(r, FALSE); // due to this FALSE - no completion!
ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
if (new_r == r)
return r;
ring old_r = r;
if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
rComplete(new_r, TRUE);
#ifdef HAVE_PLURAL
if (rIsPluralRing(old_r))
{
if ( nc_rComplete(old_r, new_r, false) ) // no qideal!
{
# ifndef SING_NDEBUG
WarnS("error in nc_rComplete"); // cleanup? rDelete(res); return r; // just go on...?
# endif
}
}
#endif
///? rChangeCurrRing(new_r);
if (old_r->qideal != NULL)
{
new_r->qideal = idrCopyR(old_r->qideal, old_r, new_r);
}
#ifdef HAVE_PLURAL
if( rIsPluralRing(old_r) )
if( nc_SetupQuotient(new_r, old_r, true) )
{
#ifndef SING_NDEBUG
WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
#endif
}
#endif
#ifdef HAVE_PLURAL
assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
assume(rIsSCA(new_r) == rIsSCA(old_r));
assume(ncRingType(new_r) == ncRingType(old_r));
#endif
rTest(new_r);
rTest(old_r);
return new_r;
}
idrCopyR
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition prCopy.cc:192
rAssure_SyzComp
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition ring.cc:4527
rDelete
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:454
rAssure_CompLastBlock
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
Definition ring.cc:4786

## rAssure_SyzOrder()

ring rAssure_SyzOrder | ( | const ring | r,
|  | BOOLEAN | complete )

Definition at line 4522 of file ring.cc.

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

## rAssure_TDeg()

ring rAssure_TDeg | ( | ring | r,
|  | int & | pos )

Definition at line 4619 of file ring.cc.

{
if (r->N==1) // special: dp(1)==lp(1)== no entry in typ
{
pos=r->VarL_LowIndex;
return r;
}
if (r->typ!=NULL)
{
for(int i=r->OrdSize-1;i>=0;i--)
{
if ((r->typ[i].ord_typ==ro_dp)
&& (r->typ[i].data.dp.start==1)
&& (r->typ[i].data.dp.end==r->N))
{
pos=r->typ[i].data.dp.place;
//printf("no change, pos=%d\n",pos);
return r;
}
}
}
#ifdef HAVE_PLURAL
nc_struct* save=r->GetNC();
r->GetNC()=NULL;
#endif
ring res=rCopy(r);
if (res->qideal!=NULL)
{
id_Delete(&res->qideal,r);
}
int j;
res->ExpL_Size=r->ExpL_Size+1; // one word more in each monom
res->PolyBin=omGetSpecBin(POLYSIZE + (res->ExpL_Size)*sizeof(long));
omFree((ADDRESS)res->ordsgn);
res->ordsgn=(long *)omAlloc0(res->ExpL_Size*sizeof(long));
for(j=0;j<r->CmpL_Size;j++)
{
res->ordsgn[j] = r->ordsgn[j];
}
res->OrdSize=r->OrdSize+1; // one block more for pSetm
if (r->typ!=NULL)
omFree((ADDRESS)res->typ);
res->typ=(sro_ord*)omAlloc0(res->OrdSize*sizeof(sro_ord));
if (r->typ!=NULL)
memcpy(res->typ,r->typ,r->OrdSize*sizeof(sro_ord));
// the additional block for pSetm: total degree at the last word
// but not included in the compare part
res->typ[res->OrdSize-1].ord_typ=ro_dp;
res->typ[res->OrdSize-1].data.dp.start=1;
res->typ[res->OrdSize-1].data.dp.end=res->N;
res->typ[res->OrdSize-1].data.dp.place=res->ExpL_Size-1;
pos=res->ExpL_Size-1;
//res->pOrdIndex=pos; //NO: think of a(1,0),dp !
extern void p_Setm_General(poly p, ring r);
res->p_Setm=p_Setm_General;
// ----------------------------
omFree((ADDRESS)res->p_Procs);
res->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
p_ProcsSet(res, res->p_Procs);
#ifdef HAVE_PLURAL
r->GetNC()=save;
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, res, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete");
#endif
// just go on..
}
}
#endif
if (r->qideal!=NULL)
{
res->qideal=idrCopyR_NoSort(r->qideal,r, res);
#ifdef HAVE_PLURAL
if (rIsPluralRing(res))
{
// nc_SetupQuotient(res, currRing);
nc_SetupQuotient(res, r); // ?
}
assume((res->qideal==NULL) == (r->qideal==NULL));
#endif
}
#ifdef HAVE_PLURAL
assume(rIsPluralRing(res) == rIsPluralRing(r));
assume(rIsSCA(res) == rIsSCA(r));
assume(ncRingType(res) == ncRingType(r));
#endif
return res;
}
ADDRESS
void * ADDRESS
Definition auxiliary.h:120
POLYSIZE
#define POLYSIZE
Definition monomials.h:233
omFree
#define omFree(addr)
Definition omAllocDecl.h:261
omGetSpecBin
#define omGetSpecBin(size)
Definition omBin.h:11
p_ProcsSet
void p_ProcsSet(ring r, p_Procs_s *p_Procs)
Definition p_Procs_Set.h:141
p_Setm_General
void p_Setm_General(poly p, const ring r)
Definition p_polys.cc:158
p_Procs_s
struct p_Procs_s p_Procs_s
Definition ring.h:24
ro_dp
@ ro_dp
Definition ring.h:53
sro_ord
Definition ring.h:225
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition simpleideals.cc:123
nc_struct
Definition nc.h:68

## rAssure_Wp_C()

ring rAssure_Wp_C | ( | const ring | r,
|  | intvec * | w )

Definition at line 4942 of file ring.cc.

{
int r_blocks = rBlocks(r);
if ((r_blocks == 3) &&
(r->order[0] == ringorder_Wp) &&
(r->order[1] == ringorder_C) &&
(r->order[2] == 0))
{
BOOLEAN ok=TRUE;
for(int i=0;i<r->N;i++)
{
if ((*w)[i]!=r->wvhdl[0][i]) { ok=FALSE;break;}
}
if (ok) return r;
}
ring res = rCopy0(r, FALSE, FALSE);
res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
res->block0 = (int*)omAlloc0(3*sizeof(int));
res->block1 = (int*)omAlloc0(3*sizeof(int));
res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
res->order[0] = ringorder_Wp;
res->order[1] = ringorder_C;
res->block0[1] = 1;
res->block1[1] = r->N;
res->wvhdl[0]=(int*)omAlloc(r->N*sizeof(int));
for(int i=0;i<r->N;i++)
{
r->wvhdl[0][i]=(*w)[i];
}
rComplete(res, 1);
if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, res, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete");
#endif
}
}
#endif
// rChangeCurrRing(res);
return res;
}
BOOLEAN
int BOOLEAN
Definition auxiliary.h:88
w
const CanonicalForm & w
Definition facAbsFact.cc:51
ringorder_Wp
@ ringorder_Wp
Definition ring.h:83

## rChangeSComps()

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

Definition at line 4497 of file ring.cc.

{
#ifdef PDEBUG
rDBChangeSComps(currComponents, currShiftedComponents, length, r);
#else
rNChangeSComps(currComponents, currShiftedComponents, r);
#endif
}
length
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
rNChangeSComps
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
Definition ring.cc:4459
rDBChangeSComps
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition ring.cc:4475
currShiftedComponents
EXTERN_VAR long * currShiftedComponents
Definition syz.h:118

## rChar()

int rChar | ( | ring | r | ) |

Definition at line 719 of file ring.cc.

{ return r->cf->ch; }

## rCharStr()

char * rCharStr | ( | const ring | r | ) |

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

Definition at line 652 of file ring.cc.

{ assume( r != NULL ); return nCoeffString(r->cf); }
nCoeffString
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:958

## rCheckIV()

BOOLEAN rCheckIV | ( | const intvec * | iv | ) |

Definition at line 176 of file ring.cc.

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

## rCheckOrdSgn()

void rCheckOrdSgn | ( | ring | r,
|  | int | i )

static

Definition at line 3944 of file ring.cc.

{ // set r->OrdSgn, r->MixedOrder
// for each variable:
int nonpos=0;
int nonneg=0;
for(int i=1;i<=r->N;i++)
{
int found=0;
// for all blocks:
for(int j=0;(j<=b) && (found==0);j++)
{
// search the first block containing var(i)
if ((r->block0[j]<=i)&&(r->block1[j]>=i))
{
// what kind if block is it?
if ((r->order[j]==ringorder_ls)
|| (r->order[j]==ringorder_ds)
|| (r->order[j]==ringorder_Ds)
|| (r->order[j]==ringorder_ws)
|| (r->order[j]==ringorder_Ws)
|| (r->order[j]==ringorder_rs))
{
r->OrdSgn=-1;
nonpos++;
found=1;
}
else if((r->order[j]==ringorder_a)
||(r->order[j]==ringorder_aa))
{
// <0: local/mixed ordering
// >0: var(i) is okay, look at other vars
// ==0: look at other blocks for var(i)
if(r->wvhdl[j][i-r->block0[j]]<0)
{
r->OrdSgn=-1;
nonpos++;
found=1;
}
else if(r->wvhdl[j][i-r->block0[j]]>0)
{
nonneg++;
found=1;
}
}
else if(r->order[j]==ringorder_M)
{
// <0: local/mixed ordering
// >0: var(i) is okay, look at other vars
// ==0: look at other blocks for var(i)
if(r->wvhdl[j][i-r->block0[j]]<0)
{
r->OrdSgn=-1;
nonpos++;
found=1;
}
else if(r->wvhdl[j][i-r->block0[j]]>0)
{
nonneg++;
found=1;
}
else
{
// very bad: try next row(s)
int add=r->block1[j]-r->block0[j]+1;
int max_i=r->block0[j]+add*add-add-1;
while(found==0)
{
i+=add;
if (r->wvhdl[j][i-r->block0[j]]<0)
{
r->OrdSgn=-1;
nonpos++;
found=1;
}
else if(r->wvhdl[j][i-r->block0[j]]>0)
{
nonneg++;
found=1;
}
else if(i>max_i)
{
nonpos++;
nonneg++;
found=1;
}
}
}
}
else if ((r->order[j]==ringorder_lp)
|| (r->order[j]==ringorder_dp)
|| (r->order[j]==ringorder_Dp)
|| (r->order[j]==ringorder_wp)
|| (r->order[j]==ringorder_Wp)
|| (r->order[j]==ringorder_rp))
{
found=1;
nonneg++;
}
}
}
}
if (nonpos>0)
{
r->OrdSgn=-1;
if (nonneg>0) r->MixedOrder=1;
}
else
{
r->OrdSgn=1;
r->MixedOrder=0;
}
}
b
CanonicalForm b
Definition cfModGcd.cc:4111
found
bool found
Definition facFactorize.cc:55
add
STATIC_VAR unsigned add[]
Definition misc_ip.cc:108
ringorder_rp
#define ringorder_rp
Definition ring.h:100
ringorder_lp
@ ringorder_lp
Definition ring.h:78
ringorder_a
@ ringorder_a
Definition ring.h:71
ringorder_ds
@ ringorder_ds
Definition ring.h:86
ringorder_Ds
@ ringorder_Ds
Definition ring.h:87
ringorder_aa
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition ring.h:93
ringorder_ws
@ ringorder_ws
Definition ring.h:88
ringorder_Ws
@ ringorder_Ws
Definition ring.h:89
ringorder_ls
@ ringorder_ls
degree, ip
Definition ring.h:85
ringorder_wp
@ ringorder_wp
Definition ring.h:82
ringorder_rs
#define ringorder_rs
Definition ring.h:101

## rComplete()

BOOLEAN rComplete | ( | ring | r,
|  | int | force )

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

{
if (r->VarOffset!=NULL && force == 0) return FALSE;
rSetOutParams(r);
int n=rBlocks(r)-1;
int i;
int bits;
r->bitmask=rGetExpSize(r->wanted_maxExp,bits,r->N);
r->BitsPerExp = bits;
r->ExpPerLong = BIT_SIZEOF_LONG / bits;
r->divmask=rGetDivMask(bits);
// will be used for ordsgn:
long *tmp_ordsgn=(long *)omAlloc0(3*(n+r->N)*sizeof(long));
// will be used for VarOffset:
int *v=(int *)omAlloc((r->N+1)*sizeof(int));
for(i=r->N; i>=0 ; i--)
{
v[i]=-1;
}
sro_ord *tmp_typ=(sro_ord *)omAlloc0(3*(n+r->N)*sizeof(sro_ord));
int typ_i=0;
int prev_ordsgn=0;
// fill in v, tmp_typ, tmp_ordsgn, determine typ_i (== ordSize)
int j=0;
int j_bits=BITS_PER_LONG;
BOOLEAN need_to_add_comp=FALSE; // Only for ringorder_s and ringorder_S!
for(i=0;i<n;i++)
{
tmp_typ[typ_i].order_index=i;
switch (r->order[i])
{
case ringorder_a:
case ringorder_aa:
rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
r->wvhdl[i]);
typ_i++;
break;
case ringorder_am:
rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
r->wvhdl[i]);
typ_i++;
break;
case ringorder_a64:
rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i], (int64 *)(r->wvhdl[i]));
typ_i++;
break;
case ringorder_c:
rO_Align(j, j_bits);
rO_LexVars_neg(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
r->ComponentOrder=1;
break;
case ringorder_C:
rO_Align(j, j_bits);
rO_LexVars(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
r->ComponentOrder=-1;
break;
case ringorder_M:
{
int k,l;
k=r->block1[i]-r->block0[i]+1; // number of vars
for(l=0;l<k;l++)
{
rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i],
r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
typ_i++;
}
break;
}
case ringorder_lp:
rO_LexVars(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
tmp_ordsgn,v,bits, -1);
break;
case ringorder_ls:
rO_LexVars_neg(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
tmp_ordsgn,v, bits, -1);
break;
case ringorder_is:
rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
tmp_ordsgn,v, bits, -1);
break;
case ringorder_ip:
rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
tmp_ordsgn,v, bits, -1);
break;
case ringorder_dp:
if (r->block0[i]==r->block1[i])
{
rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
tmp_ordsgn,v, bits, -1);
}
else
{
rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i]);
typ_i++;
rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
}
break;
case ringorder_Dp:
if (r->block0[i]==r->block1[i])
{
rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
tmp_ordsgn,v, bits, -1);
}
else
{
rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i]);
typ_i++;
rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
tmp_ordsgn,v, bits, r->block1[i]);
}
break;
case ringorder_Ip:
if (r->block0[i]==r->block1[i])
{
rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
tmp_ordsgn,v, bits, -1);
}
else
{
rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i]);
typ_i++;
rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
tmp_ordsgn,v, bits, -1);
}
break;
case ringorder_ds:
if (r->block0[i]==r->block1[i])
{
rO_LexVars_neg(j, j_bits,r->block0[i],r->block1[i],prev_ordsgn,
tmp_ordsgn,v,bits, -1);
}
else
{
rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i]);
typ_i++;
rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
}
break;
case ringorder_Ds:
if (r->block0[i]==r->block1[i])
{
rO_LexVars_neg(j, j_bits, r->block0[i],r->block0[i],prev_ordsgn,
tmp_ordsgn,v, bits, -1);
}
else
{
rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i]);
typ_i++;
rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
tmp_ordsgn,v, bits, r->block1[i]);
}
break;
case ringorder_wp:
rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i], r->wvhdl[i]);
typ_i++;
{ // check for weights <=0
int jj;
BOOLEAN have_bad_weights=FALSE;
for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
{
if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
}
if (have_bad_weights)
{
rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i]);
typ_i++;
}
}
if (r->block1[i]!=r->block0[i])
{
rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
tmp_ordsgn, v,bits, r->block0[i]);
}
break;
case ringorder_Wp:
rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i], r->wvhdl[i]);
typ_i++;
{ // check for weights <=0
int jj;
BOOLEAN have_bad_weights=FALSE;
for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
{
if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
}
if (have_bad_weights)
{
rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i]);
typ_i++;
}
}
if (r->block1[i]!=r->block0[i])
{
rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
tmp_ordsgn,v, bits, r->block1[i]);
}
break;
case ringorder_ws:
rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i], r->wvhdl[i]);
typ_i++;
if (r->block1[i]!=r->block0[i])
{
rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
tmp_ordsgn, v,bits, r->block0[i]);
}
break;
case ringorder_Ws:
rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
tmp_typ[typ_i], r->wvhdl[i]);
typ_i++;
if (r->block1[i]!=r->block0[i])
{
rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
tmp_ordsgn,v, bits, r->block1[i]);
}
break;
case ringorder_S:
assume(typ_i == 1); // For LaScala3 only: on the 2nd place ([1])!
// TODO: for K[x]: it is 0...?!
rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
need_to_add_comp=TRUE;
r->ComponentOrder=-1;
typ_i++;
break;
case ringorder_s:
assume(typ_i == 0 && j == 0);
rO_Syz(j, j_bits, prev_ordsgn, r->block0[i], tmp_ordsgn, tmp_typ[typ_i]); // set syz-limit?
need_to_add_comp=TRUE;
r->ComponentOrder=-1;
typ_i++;
break;
case ringorder_IS:
{
assume( r->block0[i] == r->block1[i] );
const int s = r->block0[i];
assume( -2 < s && s < 2);
if(s == 0) // Prefix IS
rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]); // What about prev_ordsgn?
else // s = +1 or -1 // Note: typ_i might be incremented here inside!
{
rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s); // Suffix.
need_to_add_comp=FALSE;
}
break;
}
case ringorder_unspec:
case ringorder_no:
default:
dReportError("undef. ringorder used\n");
break;
}
}
rCheckOrdSgn(r,n-1);
int j0=j; // save j
int j_bits0=j_bits; // save jbits
rO_Align(j,j_bits);
r->CmpL_Size = j;
j_bits=j_bits0; j=j0;
// fill in some empty slots with variables not already covered
// v0 is special, is therefore normally already covered
// now we do have rings without comp...
if((need_to_add_comp) && (v[0]== -1))
{
if (prev_ordsgn==1)
{
rO_Align(j, j_bits);
rO_LexVars(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
}
else
{
rO_Align(j, j_bits);
rO_LexVars_neg(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
}
}
// the variables
for(i=1 ; i<=r->N ; i++)
{
if(v[i]==(-1))
{
if (prev_ordsgn==1)
{
rO_LexVars(j, j_bits, i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
}
else
{
rO_LexVars_neg(j,j_bits,i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
}
}
}
rO_Align(j,j_bits);
// ----------------------------
// finished with constructing the monomial, computing sizes:
r->ExpL_Size=j;
r->PolyBin = omGetSpecBin(POLYSIZE + (r->ExpL_Size)*sizeof(long));
assume(r->PolyBin != NULL);
// ----------------------------
// indices and ordsgn vector for comparison
//
// r->pCompHighIndex already set
r->ordsgn=(long *)omAlloc0(r->ExpL_Size*sizeof(long));
for(j=0;j<r->CmpL_Size;j++)
{
r->ordsgn[j] = tmp_ordsgn[j];
}
omFreeSize((ADDRESS)tmp_ordsgn,(3*(n+r->N)*sizeof(long)));
// ----------------------------
// description of orderings for setm:
//
r->OrdSize=typ_i;
if (typ_i==0) r->typ=NULL;
else
{
r->typ=(sro_ord*)omAlloc(typ_i*sizeof(sro_ord));
memcpy(r->typ,tmp_typ,typ_i*sizeof(sro_ord));
}
omFreeSize((ADDRESS)tmp_typ,(3*(n+r->N)*sizeof(sro_ord)));
// ----------------------------
// indices for (first copy of ) variable entries in exp.e vector (VarOffset):
r->VarOffset=v;
// ----------------------------
// other indices
r->pCompIndex=(r->VarOffset[0] & 0xffff); //r->VarOffset[0];
i=0; // position
j=0; // index in r->typ
if (i==r->pCompIndex) i++; // IS???
while ((j < r->OrdSize)
&& ((r->typ[j].ord_typ==ro_syzcomp) ||
(r->typ[j].ord_typ==ro_syz) || (r->typ[j].ord_typ==ro_isTemp) || (r->typ[j].ord_typ==ro_is) ||
(r->order[r->typ[j].order_index] == ringorder_aa)))
{
i++; j++;
}
if (i==r->pCompIndex) i++;
r->pOrdIndex=i;
// ----------------------------
rSetDegStuff(r); // OrdSgn etc already set
rSetOption(r);
// ----------------------------
// r->p_Setm
r->p_Setm = p_GetSetmProc(r);
// ----------------------------
// set VarL_*
rSetVarL(r);
// ----------------------------
// right-adjust VarOffset
rRightAdjustVarOffset(r);
// ----------------------------
// set NegWeightL*
rSetNegWeight(r);
// ----------------------------
// p_Procs: call AFTER NegWeightL
r->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
p_ProcsSet(r, r->p_Procs);
// use totaldegree on crazy orderings:
if ((r->pFDeg==p_WTotaldegree) && rOrd_is_MixedDegree_Ordering(r))
r->pFDeg = p_Totaldegree;
return FALSE;
}
int64
long int64
Definition auxiliary.h:68
BIT_SIZEOF_LONG
#define BIT_SIZEOF_LONG
Definition auxiliary.h:80
k
int k
Definition cfEzgcd.cc:99
s
const CanonicalForm int s
Definition facAbsFact.cc:51
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
dReportError
int dReportError(const char *fmt,...)
Definition dError.cc:44
omFreeSize
#define omFreeSize(addr, size)
Definition omAllocDecl.h:260
p_WTotaldegree
long p_WTotaldegree(poly p, const ring r)
Definition p_polys.cc:612
p_GetSetmProc
p_SetmProc p_GetSetmProc(const ring r)
Definition p_polys.cc:559
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1528
rSetNegWeight
static void rSetNegWeight(ring r)
Definition ring.cc:3425
rO_ISSuffix
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:2539
rSetOption
static void rSetOption(ring r)
Definition ring.cc:3462
BITS_PER_LONG
#define BITS_PER_LONG
Definition ring.cc:40
rO_WDegree64
static void rO_WDegree64(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
Definition ring.cc:2349
rSetVarL
static void rSetVarL(ring r)
set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
Definition ring.cc:4119
rO_LexVars
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:2399
rOrd_is_MixedDegree_Ordering
BOOLEAN rOrd_is_MixedDegree_Ordering(ring r)
Definition ring.cc:3505
rSetOutParams
static void rSetOutParams(ring r)
Definition ring.cc:3141
rSetDegStuff
static void rSetDegStuff(ring r)
Definition ring.cc:3255
rO_WDegree_neg
static void rO_WDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition ring.cc:2373
rO_Syzcomp
static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
Definition ring.cc:2475
rO_TDegree
static void rO_TDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition ring.cc:2259
rO_WMDegree
static void rO_WMDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition ring.cc:2327
rO_Syz
static void rO_Syz(int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
Definition ring.cc:2490
rGetExpSize
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
Definition ring.cc:2630
rCheckOrdSgn
static void rCheckOrdSgn(ring r, int i)
Definition ring.cc:3944
rGetDivMask
static unsigned long rGetDivMask(int bits)
get r->divmask depending on bits per exponent
Definition ring.cc:4200
rRightAdjustVarOffset
static void rRightAdjustVarOffset(ring r)
right-adjust r->VarOffset
Definition ring.cc:4174
rO_ISPrefix
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
Definition ring.cc:2516
rO_Align
static void rO_Align(int &place, int &bitplace)
Definition ring.cc:2248
rO_TDegree_neg
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition ring.cc:2273
rO_WDegree
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition ring.cc:2287
rO_LexVars_neg
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:2436
ro_syz
@ ro_syz
Definition ring.h:61
ro_is
@ ro_is
Definition ring.h:62
ro_isTemp
@ ro_isTemp
Definition ring.h:62
ro_syzcomp
@ ro_syzcomp
Definition ring.h:60
ringorder_unspec
@ ringorder_unspec
Definition ring.h:96
ringorder_Ip
@ ringorder_Ip
Definition ring.h:84
ringorder_no
@ ringorder_no
Definition ring.h:70
ringorder_ip
@ ringorder_ip
Definition ring.h:80
ringorder_is
@ ringorder_is
opposite of ls
Definition ring.h:94
sro_ord::order_index
int order_index
Definition ring.h:227

## rCopy()

ring rCopy | ( | ring | r | ) |

Definition at line 1737 of file ring.cc.

{
if (r == NULL) return NULL;
ring res=rCopy0(r,FALSE,TRUE);
rComplete(res, 1); // res is purely commutative so far
if (r->qideal!=NULL) res->qideal=idrCopyR_NoSort(r->qideal, r, res);
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
if( nc_rCopy(res, r, true) ) {}
#endif
return res;
}
nc_rCopy
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
Definition old.gring.cc:2989

## rCopy0()

ring rCopy0 | ( | const ring | r,
|  | BOOLEAN | copy_qideal,
|  | BOOLEAN | copy_ordering )

Definition at line 1427 of file ring.cc.

{
if (r == NULL) return NULL;
int i,j;
ring res=(ring)omAlloc0Bin(sip_sring_bin);
//memset: res->idroot=NULL; /* local objects */
//ideal minideal;
res->options=r->options; /* ring dependent options */
//memset: res->ordsgn=NULL;
//memset: res->typ=NULL;
//memset: res->VarOffset=NULL;
//memset: res->firstwv=NULL;
//struct omBin PolyBin; /* Bin from where monoms are allocated */
//memset: res->PolyBin=NULL; // rComplete
res->cf=nCopyCoeff(r->cf); /* coeffs */
//memset: res->ref=0; /* reference counter to the ring */
res->N=rVar(r); /* number of vars */
res->firstBlockEnds=r->firstBlockEnds;
#ifdef HAVE_PLURAL
res->real_var_start=r->real_var_start;
res->real_var_end=r->real_var_end;
#endif
#ifdef HAVE_SHIFTBBA
res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
res->LPncGenCount=r->LPncGenCount;
#endif
res->VectorOut=r->VectorOut;
res->ShortOut=r->ShortOut;
res->CanShortOut=r->CanShortOut;
//memset: res->ExpL_Size=0;
//memset: res->CmpL_Size=0;
//memset: res->VarL_Size=0;
//memset: res->pCompIndex=0;
//memset: res->pOrdIndex=0;
//memset: res->OrdSize=0;
//memset: res->VarL_LowIndex=0;
//memset: res->NegWeightL_Size=0;
//memset: res->NegWeightL_Offset=NULL;
//memset: res->VarL_Offset=NULL;
// the following are set by rComplete unless predefined
// therefore, we copy these values: maybe they are non-standard
/* mask for getting single exponents */
res->bitmask=r->bitmask;
res->divmask=r->divmask;
res->BitsPerExp = r->BitsPerExp;
res->ExpPerLong = r->ExpPerLong;
//memset: res->p_Procs=NULL;
//memset: res->pFDeg=NULL;
//memset: res->pLDeg=NULL;
//memset: res->pFDegOrig=NULL;
//memset: res->pLDegOrig=NULL;
//memset: res->p_Setm=NULL;
//memset: res->cf=NULL;
/*
if (r->extRing!=NULL)
r->extRing->ref++;
res->extRing=r->extRing;
//memset: res->qideal=NULL;
*/
if (copy_ordering == TRUE)
{
res->LexOrder=r->LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
res->MixedOrder=r->MixedOrder; // TRUE for mixed (global/local) ordering, FALSE otherwise,
i=rBlocks(r);
res->wvhdl = (int **)omAlloc(i * sizeof(int *));
res->order = (rRingOrder_t *) omAlloc(i * sizeof(rRingOrder_t));
res->block0 = (int *) omAlloc(i * sizeof(int));
res->block1 = (int *) omAlloc(i * sizeof(int));
for (j=0; j<i; j++)
{
if (r->wvhdl[j]!=NULL)
{
#ifdef HAVE_OMALLOC
res->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
#else
{
int l=r->block1[j]-r->block0[j]+1;
if (r->order[j]==ringorder_a64) l*=2;
else if (r->order[j]==ringorder_M) l=l*l;
else if (r->order[j]==ringorder_am)
{
l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
}
res->wvhdl[j]=(int*)omalloc(l*sizeof(int));
memcpy(res->wvhdl[j],r->wvhdl[j],l*sizeof(int));
}
#endif
}
else
res->wvhdl[j]=NULL;
}
memcpy(res->order,r->order,i * sizeof(rRingOrder_t));
memcpy(res->block0,r->block0,i * sizeof(int));
memcpy(res->block1,r->block1,i * sizeof(int));
}
//memset: else
//memset: {
//memset: res->wvhdl = NULL;
//memset: res->order = NULL;
//memset: res->block0 = NULL;
//memset: res->block1 = NULL;
//memset: }
res->names = (char **)omAlloc0(rVar(r) * sizeof(char *));
for (i=0; i<rVar(res); i++)
{
res->names[i] = omStrDup(r->names[i]);
}
if (r->qideal!=NULL)
{
if (copy_qideal)
{
assume(copy_ordering);
rComplete(res);
res->qideal= idrCopyR_NoSort(r->qideal, r, res);
rUnComplete(res);
}
//memset: else res->qideal = NULL;
}
//memset: else res->qideal = NULL;
//memset: res->GetNC() = NULL; // copy is purely commutative!!!
return res;
}
nCopyCoeff
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition coeffs.h:439
omStrDup
#define omStrDup(s)
Definition omAllocDecl.h:263
omAlloc0Bin
#define omAlloc0Bin(bin)
Definition omAllocDecl.h:206
sip_sring_bin
VAR omBin sip_sring_bin
Definition ring.cc:43
rUnComplete
void rUnComplete(ring r)
Definition ring.cc:4057

## rCopy0AndAddA()

ring rCopy0AndAddA | ( | const ring | r,
|  | int64vec * | wv64,
|  | BOOLEAN | copy_qideal,
|  | BOOLEAN | copy_ordering )

Definition at line 1570 of file ring.cc.

{
if (r == NULL) return NULL;
int i,j;
ring res=(ring)omAlloc0Bin(sip_sring_bin);
//memcpy(res,r,sizeof(ip_sring));
//memset: res->idroot=NULL; /* local objects */
//ideal minideal;
res->options=r->options; /* ring dependent options */
//memset: res->ordsgn=NULL;
//memset: res->typ=NULL;
//memset: res->VarOffset=NULL;
//memset: res->firstwv=NULL;
//struct omBin PolyBin; /* Bin from where monoms are allocated */
//memset: res->PolyBin=NULL; // rComplete
res->cf=nCopyCoeff(r->cf); /* coeffs */
//memset: res->ref=0; /* reference counter to the ring */
res->N=rVar(r); /* number of vars */
res->firstBlockEnds=r->firstBlockEnds;
#ifdef HAVE_PLURAL
res->real_var_start=r->real_var_start;
res->real_var_end=r->real_var_end;
#endif
#ifdef HAVE_SHIFTBBA
res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
res->LPncGenCount=r->LPncGenCount;
#endif
res->VectorOut=r->VectorOut;
res->ShortOut=r->ShortOut;
res->CanShortOut=r->CanShortOut;
res->LexOrder=r->LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
res->MixedOrder=r->MixedOrder; // TRUE for mixed (global/local) ordering, FALSE otherwise,
//memset: res->ExpL_Size=0;
//memset: res->CmpL_Size=0;
//memset: res->VarL_Size=0;
//memset: res->pCompIndex=0;
//memset: res->pOrdIndex=0;
//memset: res->OrdSize=0;
//memset: res->VarL_LowIndex=0;
//memset: res->NegWeightL_Size=0;
//memset: res->NegWeightL_Offset=NULL;
//memset: res->VarL_Offset=NULL;
// the following are set by rComplete unless predefined
// therefore, we copy these values: maybe they are non-standard
/* mask for getting single exponents */
res->bitmask=r->bitmask;
res->divmask=r->divmask;
res->BitsPerExp = r->BitsPerExp;
res->ExpPerLong = r->ExpPerLong;
//memset: res->p_Procs=NULL;
//memset: res->pFDeg=NULL;
//memset: res->pLDeg=NULL;
//memset: res->pFDegOrig=NULL;
//memset: res->pLDegOrig=NULL;
//memset: res->p_Setm=NULL;
//memset: res->cf=NULL;
/*
if (r->extRing!=NULL)
r->extRing->ref++;
res->extRing=r->extRing;
//memset: res->qideal=NULL;
*/
if (copy_ordering == TRUE)
{
i=rBlocks(r)+1; // DIFF to rCopy0
res->wvhdl = (int **)omAlloc(i * sizeof(int *));
res->order = (rRingOrder_t *) omAlloc(i * sizeof(rRingOrder_t));
res->block0 = (int *) omAlloc(i * sizeof(int));
res->block1 = (int *) omAlloc(i * sizeof(int));
for (j=0; j<i-1; j++)
{
if (r->wvhdl[j]!=NULL)
{
#ifdef HAVE_OMALLOC
res->wvhdl[j+1] = (int*) omMemDup(r->wvhdl[j]); //DIFF
#else
{
int l=r->block1[j]-r->block0[j]+1;
if (r->order[j]==ringorder_a64) l*=2;
else if (r->order[j]==ringorder_M) l=l*l;
else if (r->order[j]==ringorder_am)
{
l+=r->wvhdl[j][r->block1[j]-r->block0[j]+1]+1;
}
res->wvhdl[j+1]=(int*)omalloc(l*sizeof(int));
memcpy(res->wvhdl[j+1],r->wvhdl[j],l*sizeof(int));
}
#endif
}
else
res->wvhdl[j+1]=NULL; //DIFF
}
memcpy(&(res->order[1]),r->order,(i-1) * sizeof(rRingOrder_t)); //DIFF
memcpy(&(res->block0[1]),r->block0,(i-1) * sizeof(int)); //DIFF
memcpy(&(res->block1[1]),r->block1,(i-1) * sizeof(int)); //DIFF
}
//memset: else
//memset: {
//memset: res->wvhdl = NULL;
//memset: res->order = NULL;
//memset: res->block0 = NULL;
//memset: res->block1 = NULL;
//memset: }
//the added A
res->order[0]=ringorder_a64;
int length=wv64->rows();
int64 *A=(int64 *)omAlloc(length*sizeof(int64));
for(j=length-1;j>=0;j--)
{
A[j]=(*wv64)[j];
}
res->wvhdl[0]=(int *)A;
res->block0[0]=1;
res->block1[0]=length;
//
res->names = (char **)omAlloc0(rVar(r) * sizeof(char *));
for (i=0; i<rVar(res); i++)
{
res->names[i] = omStrDup(r->names[i]);
}
if (r->qideal!=NULL)
{
if (copy_qideal)
{
#ifndef SING_NDEBUG
if (!copy_ordering)
WerrorS("internal error: rCopy0(Q,TRUE,FALSE)");
else
#endif
{
#ifndef SING_NDEBUG
WarnS("internal bad stuff: rCopy0(Q,TRUE,TRUE)");
#endif
rComplete(res);
res->qideal= idrCopyR_NoSort(r->qideal, r, res);
rUnComplete(res);
}
}
//memset: else res->qideal = NULL;
}
//memset: else res->qideal = NULL;
//memset: res->GetNC() = NULL; // copy is purely commutative!!!
return res;
}
int64vec::rows
int rows() const
Definition int64vec.h:66

## rDBChangeSComps()

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

inline static

Definition at line 4475 of file ring.cc.

{
assume(r->typ[1].ord_typ == ro_syzcomp);
r->typ[1].data.syzcomp.length = length;
rNChangeSComps( currComponents, currShiftedComponents, r);
}

## rDBGetSComps()

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

inline static

Definition at line 4485 of file ring.cc.

{
assume(r->typ[1].ord_typ == ro_syzcomp);
*length = r->typ[1].data.syzcomp.length;
rNGetSComps( currComponents, currShiftedComponents, r);
}
rNGetSComps
static void rNGetSComps(int **currComponents, long **currShiftedComponents, ring r)
Definition ring.cc:4467

## rDBTest()

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

Definition at line 2098 of file ring.cc.

{
int i,j;
if (r == NULL)
{
dReportError("Null ring in %s:%d", fn, l);
return FALSE;
}
if (r->N == 0) return TRUE;
if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
{
dReportError("missing OrdSgn in %s:%d", fn, l);
return FALSE;
}
// omCheckAddrSize(r,sizeof(ip_sring));
#if OM_CHECK > 0
i=rBlocks(r);
omCheckAddrSize(r->order,i*sizeof(int));
omCheckAddrSize(r->block0,i*sizeof(int));
omCheckAddrSize(r->block1,i*sizeof(int));
for(int j=0;j<=i;j++)
{
if((r->order[j]<0)||(r->order[j]>ringorder_unspec))
dError("wrong order in r->order");
}
if (r->wvhdl!=NULL)
{
omCheckAddrSize(r->wvhdl,i*sizeof(int *));
for (j=0;j<i; j++)
{
if (r->wvhdl[j] != NULL) omCheckAddr(r->wvhdl[j]);
}
}
#endif
if (r->VarOffset == NULL)
{
dReportError("Null ring VarOffset -- no rComplete (?) in n %s:%d", fn, l);
return FALSE;
}
omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(int));
if ((r->OrdSize==0)!=(r->typ==NULL))
{
dReportError("mismatch OrdSize and typ-pointer in %s:%d");
return FALSE;
}
omcheckAddrSize(r->typ,r->OrdSize*sizeof(*(r->typ)));
omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(*(r->VarOffset)));
// test assumptions:
for(i=0;i<=r->N;i++) // for all variables (i = 0..N)
{
if(r->typ!=NULL)
{
for(j=0;j<r->OrdSize;j++) // for all ordering blocks (j =0..OrdSize-1)
{
if(r->typ[j].ord_typ == ro_isTemp)
{
const int p = r->typ[j].data.isTemp.suffixpos;
if(p <= j)
dReportError("ordrec prefix %d is unmatched",j);
assume( p < r->OrdSize );
if(r->typ[p].ord_typ != ro_is)
dReportError("ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
// Skip all intermediate blocks for undone variables:
if(r->typ[j].data.isTemp.pVarOffset[i] != -1) // Check i^th variable
{
j = p - 1; // SKIP ALL INTERNAL BLOCKS...???
continue; // To make for check OrdSize bound...
}
}
else if (r->typ[j].ord_typ == ro_is)
{
// Skip all intermediate blocks for undone variables:
if(r->typ[j].data.is.pVarOffset[i] != -1)
{
// TODO???
}
}
else
{
if (r->typ[j].ord_typ==ro_cp)
{
if(((short)r->VarOffset[i]) == r->typ[j].data.cp.place)
dReportError("ordrec %d conflicts with var %d",j,i);
}
else
if ((r->typ[j].ord_typ!=ro_syzcomp)
&& (r->VarOffset[i] == r->typ[j].data.dp.place))
dReportError("ordrec %d conflicts with var %d",j,i);
}
}
}
int tmp;
tmp=r->VarOffset[i] & 0xffffff;
#if SIZEOF_LONG == 8
if ((r->VarOffset[i] >> 24) >63)
#else
if ((r->VarOffset[i] >> 24) >31)
#endif
dReportError("bit_start out of range:%d",r->VarOffset[i] >> 24);
if (i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
{
dReportError("varoffset out of range for var %d: %d",i,tmp);
}
}
if(r->typ!=NULL)
{
for(j=0;j<r->OrdSize;j++)
{
if ((r->typ[j].ord_typ==ro_dp)
|| (r->typ[j].ord_typ==ro_wp)
|| (r->typ[j].ord_typ==ro_wp_neg))
{
if (r->typ[j].data.dp.start > r->typ[j].data.dp.end)
dReportError("in ordrec %d: start(%d) > end(%d)",j,
r->typ[j].data.dp.start, r->typ[j].data.dp.end);
if ((r->typ[j].data.dp.start < 1)
|| (r->typ[j].data.dp.end > r->N))
dReportError("in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",j,
r->typ[j].data.dp.start, r->typ[j].data.dp.end,r->N);
}
}
}
assume(r != NULL);
assume(r->cf != NULL);
if (nCoeff_is_algExt(r->cf))
{
assume(r->cf->extRing != NULL);
assume(r->cf->extRing->qideal != NULL);
omCheckAddr(r->cf->extRing->qideal->m[0]);
}
//assume(r->cf!=NULL);
return TRUE;
}
nCoeff_is_algExt
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition coeffs.h:905
omCheckAddr
#define omCheckAddr(addr)
Definition omAllocDecl.h:328
omCheckAddrSize
#define omCheckAddrSize(addr, size)
Definition omAllocDecl.h:327
omcheckAddrSize
#define omcheckAddrSize(addr, size)
Definition omAllocDecl.h:329
ro_cp
@ ro_cp
Definition ring.h:59
ro_wp_neg
@ ro_wp_neg
Definition ring.h:57
ro_wp
@ ro_wp
Definition ring.h:54

## rDebugPrint()

void rDebugPrint | ( | const ring | r | ) |

Definition at line 4214 of file ring.cc.

{
if (r==NULL)
{
PrintS("NULL ?\n");
return;
}
// corresponds to ro_typ from ring.h:
const char *TYP[]={"ro_dp","ro_wp","ro_am","ro_wp64","ro_wp_neg","ro_cp",
"ro_syzcomp", "ro_syz", "ro_isTemp", "ro_is", "ro_none"};
int i,j;
Print("ExpL_Size:%d ",r->ExpL_Size);
Print("CmpL_Size:%d ",r->CmpL_Size);
Print("VarL_Size:%d\n",r->VarL_Size);
Print("bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
Print("divmask=%lx\n", r->divmask);
Print("BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
Print("VarL_LowIndex: %d\n", r->VarL_LowIndex);
PrintS("VarL_Offset:\n");
if (r->VarL_Offset==NULL) PrintS(" NULL");
else
for(j = 0; j < r->VarL_Size; j++)
Print(" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
PrintLn();
PrintS("VarOffset:\n");
if (r->VarOffset==NULL) PrintS(" NULL\n");
else
for(j=0;j<=r->N;j++)
Print(" v%d at e-pos %d, bit %d\n",
j,r->VarOffset[j] & 0xffffff, r->VarOffset[j] >>24);
PrintS("ordsgn:\n");
for(j=0;j<r->CmpL_Size;j++)
Print(" ordsgn %ld at pos %d\n",r->ordsgn[j],j);
Print("OrdSgn:%d\n",r->OrdSgn);
PrintS("ordrec:\n");
for(j=0;j<r->OrdSize;j++)
{
Print(" typ %s", TYP[r->typ[j].ord_typ]);
if (r->typ[j].ord_typ==ro_syz)
{
const short place = r->typ[j].data.syz.place;
const int limit = r->typ[j].data.syz.limit;
const int curr_index = r->typ[j].data.syz.curr_index;
const int* syz_index = r->typ[j].data.syz.syz_index;
Print(" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
if( syz_index == NULL )
PrintS("(NULL)");
else
{
PrintS("{");
for( i=0; i <= limit; i++ )
Print("%d ", syz_index[i]);
PrintS("}");
}
}
else if (r->typ[j].ord_typ==ro_isTemp)
{
Print(" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
}
else if (r->typ[j].ord_typ==ro_is)
{
Print(" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
// 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]);
Print(" limit %d",r->typ[j].data.is.limit);
#ifndef SING_NDEBUG
//PrintS(" F: ");idShow(r->typ[j].data.is.F, r, r, 1);
#endif
PrintLn();
}
else if (r->typ[j].ord_typ==ro_am)
{
Print(" place %d",r->typ[j].data.am.place);
Print(" start %d",r->typ[j].data.am.start);
Print(" end %d",r->typ[j].data.am.end);
Print(" len_gen %d",r->typ[j].data.am.len_gen);
PrintS(" w:");
int l=0;
for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
Print(" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
l=r->typ[j].data.am.end+1;
int ll=r->typ[j].data.am.weights[l-r->typ[j].data.am.start];
PrintS(" m:");
for(int lll=l+1;lll<l+ll+1;lll++)
Print(" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
}
else
{
Print(" place %d",r->typ[j].data.dp.place);
if (r->typ[j].ord_typ!=ro_syzcomp && r->typ[j].ord_typ!=ro_syz)
{
Print(" start %d",r->typ[j].data.dp.start);
Print(" end %d",r->typ[j].data.dp.end);
if ((r->typ[j].ord_typ==ro_wp)
|| (r->typ[j].ord_typ==ro_wp_neg))
{
PrintS(" w:");
for(int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;l++)
Print(" %d",r->typ[j].data.wp.weights[l-r->typ[j].data.wp.start]);
}
else if (r->typ[j].ord_typ==ro_wp64)
{
PrintS(" w64:");
int l;
for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
Print(" %ld",(long)(r->typ[j].data.wp64.weights64+l-r->typ[j].data.wp64.start));
}
}
}
PrintLn();
}
Print("pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
Print("OrdSize:%d\n",r->OrdSize);
PrintS("--------------------\n");
for(j=0;j<r->ExpL_Size;j++)
{
Print("L[%d]: ",j);
if (j< r->CmpL_Size)
Print("ordsgn %ld ", r->ordsgn[j]);
else
PrintS("no comp ");
i=1;
for(;i<=r->N;i++)
{
if( (r->VarOffset[i] & 0xffffff) == j )
{ Print("v%d at e[%d], bit %d; ", i,r->VarOffset[i] & 0xffffff,
r->VarOffset[i] >>24 ); }
}
if( r->pCompIndex==j ) PrintS("v0; ");
for(i=0;i<r->OrdSize;i++)
{
if (r->typ[i].data.dp.place == j)
{
Print("ordrec:%s (start:%d, end:%d) ",TYP[r->typ[i].ord_typ],
r->typ[i].data.dp.start, r->typ[i].data.dp.end);
}
}
if (j==r->pOrdIndex)
PrintS("pOrdIndex\n");
else
PrintLn();
}
Print("LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
Print("NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
if (r->NegWeightL_Offset==NULL) PrintS(" NULL");
else
for(j = 0; j < r->NegWeightL_Size; j++)
Print(" [%d]: %d ", j, r->NegWeightL_Offset[j]);
PrintLn();
// p_Procs stuff
p_Procs_s proc_names;
const char* field;
const char* length;
const char* ord;
p_Debug_GetProcNames(r, &proc_names); // changes p_Procs!!!
p_Debug_GetSpecNames(r, field, length, ord);
Print("p_Spec : %s, %s, %s\n", field, length, ord);
PrintS("p_Procs :\n");
for (i=0; i<(int) (sizeof(p_Procs_s)/sizeof(void*)); i++)
{
Print(" %s,\n", ((char**) &proc_names)[i]);
}
{
PrintLn();
PrintS("pFDeg : ");
#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
pFDeg_CASE(p_Totaldegree); else
pFDeg_CASE(p_WFirstTotalDegree); else
pFDeg_CASE(p_WTotaldegree); else
pFDeg_CASE(p_Deg); else
#undef pFDeg_CASE
Print("(%p)", r->pFDeg); // default case
PrintLn();
Print("pLDeg : (%p)", r->pLDeg);
PrintLn();
}
PrintS("pSetm:");
void p_Setm_Dummy(poly p, const ring r);
void p_Setm_TotalDegree(poly p, const ring r);
void p_Setm_WFirstTotalDegree(poly p, const ring r);
void p_Setm_General(poly p, const ring r);
if (r->p_Setm==p_Setm_General) PrintS("p_Setm_General\n");
else if (r->p_Setm==p_Setm_Dummy) PrintS("p_Setm_Dummy\n");
else if (r->p_Setm==p_Setm_TotalDegree) PrintS("p_Setm_Totaldegree\n");
else if (r->p_Setm==p_Setm_WFirstTotalDegree) PrintS("p_Setm_WFirstTotalDegree\n");
else Print("%p\n",r->p_Setm);
}
p_Debug_GetProcNames
void p_Debug_GetProcNames(const ring r, p_Procs_s *p_Procs)
Definition p_Procs_Set.h:232
p_Debug_GetSpecNames
void p_Debug_GetSpecNames(const ring r, const char *&field, const char *&length, const char *&ord)
Definition p_Procs_Set.h:221
p_Setm_WFirstTotalDegree
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:553
p_WFirstTotalDegree
long p_WFirstTotalDegree(poly p, const ring r)
Definition p_polys.cc:595
p_Setm_Dummy
void p_Setm_Dummy(poly p, const ring r)
Definition p_polys.cc:540
p_Setm_TotalDegree
void p_Setm_TotalDegree(poly p, const ring r)
Definition p_polys.cc:546
p_Deg
long p_Deg(poly a, const ring r)
Definition p_polys.cc:586
pFDeg_CASE
#define pFDeg_CASE(A)
ro_wp64
@ ro_wp64
Definition ring.h:56
ro_am
@ ro_am
Definition ring.h:55

## rDefault() [1/4]

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

Definition at line 139 of file ring.cc.

{
assume( cf != NULL);
/*order: o=lp,0*/
rRingOrder_t *order = (rRingOrder_t *) omAlloc(2* sizeof(rRingOrder_t));
int *block0 = (int *)omAlloc0(2 * sizeof(int));
int *block1 = (int *)omAlloc0(2 * sizeof(int));
/* ringorder o=lp for the first block: var 1..N */
order[0] = o;
block0[0] = 1;
block1[0] = N;
/* the last block: everything is 0 */
order[1] = (rRingOrder_t)0;
return rDefault(cf,N,n,2,order,block0,block1);
}
cf
CanonicalForm cf
Definition cfModGcd.cc:4091
rDefault
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:103

## rDefault() [2/4]

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 at line 103 of file ring.cc.

{
assume( cf != NULL);
ring r=(ring) omAlloc0Bin(sip_sring_bin);
r->N = N;
r->cf = cf;
/*rPar(r) = 0; Alloc0 */
/*names*/
r->names = (char **) omAlloc0(N * sizeof(char *));
int i;
for(i=0;i<N;i++)
{
r->names[i] = omStrDup(n[i]);
}
/*weights: entries for 2 blocks: NULL*/
if (wvhdl==NULL)
r->wvhdl = (int **)omAlloc0((ord_size+1) * sizeof(int *));
else
r->wvhdl=wvhdl;
r->order = ord;
r->block0 = block0;
r->block1 = block1;
if (bitmask!=0) r->wanted_maxExp=bitmask;
/* complete ring initializations */
rComplete(r);
return r;
}

## rDefault() [3/4]

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

Definition at line 156 of file ring.cc.

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

## rDefault() [4/4]

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

Definition at line 131 of file ring.cc.

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

## rDelete()

void rDelete | ( | ring | r | ) |

unconditionally deletes fields in r

Definition at line 454 of file ring.cc.

{
int i, j;
if (r == NULL) return;
if( r->ref > 0 ) // ->ref means the number of Interpreter objects referring to the ring...
return;
if (r->ppNoether!=NULL) p_Delete(&(r->ppNoether),r);
if( r->qideal != NULL )
{
ideal q = r->qideal;
r->qideal = NULL;
id_Delete(&q, r);
}
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
nc_rKill(r);
#endif
rUnComplete(r); // may need r->cf for p_Delete
nKillChar(r->cf); r->cf = NULL;
// delete order stuff
if (r->order != NULL)
{
i=rBlocks(r);
assume(r->block0 != NULL && r->block1 != NULL && r->wvhdl != NULL);
// delete order
omFreeSize((ADDRESS)r->order,i*sizeof(rRingOrder_t));
omFreeSize((ADDRESS)r->block0,i*sizeof(int));
omFreeSize((ADDRESS)r->block1,i*sizeof(int));
// delete weights
for (j=0; j<i; j++)
{
if (r->wvhdl[j]!=NULL)
omFree(r->wvhdl[j]);
}
omFreeSize((ADDRESS)r->wvhdl,i*sizeof(int *));
}
else
{
assume(r->block0 == NULL && r->block1 == NULL && r->wvhdl == NULL);
}
// delete varnames
if(r->names!=NULL)
{
for (i=0; i<r->N; i++)
{
if (r->names[i] != NULL) omFree((ADDRESS)r->names[i]);
}
omFreeSize((ADDRESS)r->names,r->N*sizeof(char *));
}
omFreeBin(r, sip_sring_bin);
}
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition numbers.cc:563
nc_rKill
void nc_rKill(ring r)
complete destructor
Definition old.gring.cc:2483
omFreeBin
#define omFreeBin(addr, bin)
Definition omAllocDecl.h:259
p_Delete
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903

## rEnvelope()

ring rEnvelope | ( | ring | R | ) |

Definition at line 5819 of file ring.cc.

{
ring Ropp = rOpposite(R);
ring Renv = NULL;
int stat = rSum(R, Ropp, Renv); /* takes care of qideals */
if ( stat <=0 )
WarnS("Error in rEnvelope at rSum");
rTest(Renv);
return Renv;
}
rSum
int rSum(ring r1, ring r2, ring &sum)
Definition ring.cc:1408
rOpposite
ring rOpposite(ring src)
Definition ring.cc:5425

## rEqual()

BOOLEAN rEqual | ( | ring | r1,
|  | ring | r2,
|  | BOOLEAN | qr )

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

{
if (r1 == r2) return TRUE;
if (r1 == NULL || r2 == NULL) return FALSE;
if (r1->cf!=r2->cf) return FALSE;
if (rVar(r1)!=rVar(r2)) return FALSE;
if (r1->bitmask!=r2->bitmask) return FALSE;
#ifdef HAVE_SHIFTBBA
if (r1->isLPring!=r2->isLPring) return FALSE;
if (r1->LPncGenCount!=r2->LPncGenCount) return FALSE;
#endif
if( !rSamePolyRep(r1, r2) )
return FALSE;
int i/*, j*/;
for (i=0; i<rVar(r1); i++)
{
if ((r1->names[i] != NULL) && (r2->names[i] != NULL))
{
if (strcmp(r1->names[i], r2->names[i])) return FALSE;
}
else if ((r1->names[i] != NULL) ^ (r2->names[i] != NULL))
{
return FALSE;
}
}
if (qr)
{
if (r1->qideal != NULL)
{
ideal id1 = r1->qideal, id2 = r2->qideal;
int i, n;
poly *m1, *m2;
if (id2 == NULL) return FALSE;
if ((n = IDELEMS(id1)) != IDELEMS(id2)) return FALSE;
{
m1 = id1->m;
m2 = id2->m;
for (i=0; i<n; i++)
if (! p_EqualPolys(m1[i],m2[i], r1, r2)) return FALSE;
}
}
else if (r2->qideal != NULL) return FALSE;
}
return TRUE;
}
qr
Definition qr.h:46
p_EqualPolys
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition p_polys.cc:4666
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 analo...
Definition ring.cc:1805
IDELEMS
#define IDELEMS(i)
Definition simpleideals.h:23

## rGetDivMask()

unsigned long rGetDivMask | ( | int | bits | ) |

static

get r->divmask depending on bits per exponent

Definition at line 4200 of file ring.cc.

{
unsigned long divmask = 1;
int i = bits;
while (i < BIT_SIZEOF_LONG)
{
divmask |= (((unsigned long) 1) << (unsigned long) i);
i += bits;
}
return divmask;
}

## rGetExpSize() [1/2]

unsigned long rGetExpSize | ( | unsigned long | bitmask,
|  | int & | bits )

static

Definition at line 2630 of file ring.cc.

{
if (bitmask == 0)
{
bits=16; bitmask=0xffff;
}
else if (bitmask <= 1L)
{
bits=1; bitmask = 1L;
}
else if (bitmask <= 3L)
{
bits=2; bitmask = 3L;
}
else if (bitmask <= 7L)
{
bits=3; bitmask=7L;
}
else if (bitmask <= 0xfL)
{
bits=4; bitmask=0xfL;
}
else if (bitmask <= 0x1fL)
{
bits=5; bitmask=0x1fL;
}
else if (bitmask <= 0x3fL)
{
bits=6; bitmask=0x3fL;
}
#if SIZEOF_LONG == 8
else if (bitmask <= 0x7fL)
{
bits=7; bitmask=0x7fL; /* 64 bit longs only */
}
#endif
else if (bitmask <= 0xffL)
{
bits=8; bitmask=0xffL;
}
#if SIZEOF_LONG == 8
else if (bitmask <= 0x1ffL)
{
bits=9; bitmask=0x1ffL; /* 64 bit longs only */
}
#endif
else if (bitmask <= 0x3ffL)
{
bits=10; bitmask=0x3ffL;
}
#if SIZEOF_LONG == 8
else if (bitmask <= 0xfffL)
{
bits=12; bitmask=0xfff; /* 64 bit longs only */
}
#endif
else if (bitmask <= 0xffffL)
{
bits=16; bitmask=0xffffL;
}
#if SIZEOF_LONG == 8
else if (bitmask <= 0xfffffL)
{
bits=20; bitmask=0xfffffL; /* 64 bit longs only */
}
else if (bitmask <= 0xffffffffL)
{
bits=32; bitmask=0xffffffffL;
}
else if (bitmask <= 0x7fffffffffffffffL)
{
bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
}
else
{
bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
}
#else
else if (bitmask <= 0x7fffffff)
{
bits=31; bitmask=0x7fffffff; /* for overflow tests*/
}
else
{
bits=31; bitmask=0x7fffffffL; /* for overflow tests*/
}
#endif
return bitmask;
}

## rGetExpSize() [2/2]

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

Definition at line 2723 of file ring.cc.

{
bitmask =rGetExpSize(bitmask, bits);
int vars_per_long=BIT_SIZEOF_LONG/bits;
int bits1;
loop
{
if (bits == BIT_SIZEOF_LONG-1)
{
bits = BIT_SIZEOF_LONG - 1;
return LONG_MAX;
}
unsigned long bitmask1 =rGetExpSize(bitmask+1, bits1);
int vars_per_long1=BIT_SIZEOF_LONG/bits1;
if ((((N+vars_per_long-1)/vars_per_long) ==
((N+vars_per_long1-1)/vars_per_long1)))
{
vars_per_long=vars_per_long1;
bits=bits1;
bitmask=bitmask1;
}
else
{
return bitmask; /* and bits */
}
}
}
loop
#define loop
Definition structs.h:71

## rGetISPos()

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! p - starts with 0!

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

Definition at line 5144 of file ring.cc.

{
// Put the reference set F into the ring -ordering -recor
#if MYTEST
Print("rIsIS(p: %d)\nF:", p);
PrintLn();
#endif
if (r->typ==NULL)
{
// dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
return -1;
}
int j = p; // Which IS record to use...
for( int pos = 0; pos < r->OrdSize; pos++ )
if( r->typ[pos].ord_typ == ro_is)
if( j-- == 0 )
return pos;
return -1;
}

## rGetMaxSyzComp()

int rGetMaxSyzComp | ( | int | i,
|  | const ring | r )

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

Definition at line 5302 of file ring.cc.

{
if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz) &&
r->typ[0].data.syz.limit > 0 && i > 0)
{
assume(i <= r->typ[0].data.syz.limit);
int j;
for (j=0; j<r->typ[0].data.syz.limit; j++)
{
if (r->typ[0].data.syz.syz_index[j] == i &&
r->typ[0].data.syz.syz_index[j+1] != i)
{
assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
return j;
}
}
return r->typ[0].data.syz.limit;
}
else
{
#ifndef SING_NDEBUG
WarnS("rGetMaxSyzComp: order c");
#endif
return 0;
}
}

## rGetOrderType()

rOrderType_t rGetOrderType | ( | ring | r | ) |

Definition at line 1846 of file ring.cc.

{
// check for simple ordering
if (rHasSimpleOrder(r))
{
if ((r->order[1] == ringorder_c)
|| (r->order[1] == ringorder_C))
{
switch(r->order[0])
{
case ringorder_dp:
case ringorder_wp:
case ringorder_ds:
case ringorder_ws:
case ringorder_ls:
case ringorder_unspec:
if (r->order[1] == ringorder_C
|| r->order[0] == ringorder_unspec)
return rOrderType_ExpComp;
return rOrderType_Exp;
default:
assume(r->order[0] == ringorder_lp ||
r->order[0] == ringorder_rs ||
r->order[0] == ringorder_Dp ||
r->order[0] == ringorder_Wp ||
r->order[0] == ringorder_Ds ||
r->order[0] == ringorder_Ws);
if (r->order[1] == ringorder_c) return rOrderType_ExpComp;
return rOrderType_Exp;
}
}
else
{
assume((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C));
return rOrderType_CompExp;
}
}
else
return rOrderType_General;
}
rHasSimpleOrder
BOOLEAN rHasSimpleOrder(const ring r)
Definition ring.cc:1893
rOrderType_CompExp
@ rOrderType_CompExp
simple ordering, component has priority
Definition ring.h:106
rOrderType_Exp
@ rOrderType_Exp
simple ordering, exponent vector has priority component is compatible with exp-vector order
Definition ring.h:109
rOrderType_General
@ rOrderType_General
non-simple ordering as specified by currRing
Definition ring.h:105
rOrderType_ExpComp
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
Definition ring.h:107

## rGetSComps()

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

Definition at line 4506 of file ring.cc.

{
#ifdef PDEBUG
rDBGetSComps(currComponents, currShiftedComponents, length, r);
#else
rNGetSComps(currComponents, currShiftedComponents, r);
#endif
}
rDBGetSComps
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition ring.cc:4485

## rGetVar()

poly rGetVar | ( | const int | varIndex,
|  | const ring | r )

Definition at line 5911 of file ring.cc.

{
poly p = p_ISet(1, r);
p_SetExp(p, varIndex, 1, r);
p_Setm(p, r);
return p;
}
p_ISet
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition p_polys.cc:1298
p_SetExp
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:490
p_Setm
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235

## rGetWeightVec()

int64 * rGetWeightVec | ( | const ring | r | ) |

Definition at line 5366 of file ring.cc.

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

## rHas_c_Ordering()

BOOLEAN rHas_c_Ordering | ( | const ring | r | ) |

Definition at line 1889 of file ring.cc.

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

## rHasBlockOrder()

BOOLEAN rHasBlockOrder | ( | const ring | r | ) |

Definition at line 1924 of file ring.cc.

{
if (r->order[0] == ringorder_s) return FALSE;
int s=0;
if ((r->order[0] == ringorder_c)
|| (r->order[0] == ringorder_C)) s=1;
if ((r->block0[s]!=1)||(r->block1[s]!=r->N))
return TRUE;
if ((r->order[s] == ringorder_lp)
|| (r->order[s] == ringorder_rp)
|| (r->order[s] == ringorder_ls)
|| (r->order[s] == ringorder_rs))
return TRUE;
if(r->order[s] == ringorder_a)
{
for(int i=0;i<r->N;i++) // we have: block0[s]=1, block1[s]=N
{
if(r->wvhdl[s][i]==0) return TRUE;
}
}
return FALSE;
}

## rHasSimpleLexOrder()

BOOLEAN rHasSimpleLexOrder | ( | const ring | r | ) |

returns TRUE, if simple lp or ls ordering

Definition at line 1949 of file ring.cc.

{
return rHasSimpleOrder(r) &&
(r->order[0] == ringorder_ls ||
r->order[0] == ringorder_lp ||
r->order[1] == ringorder_ls ||
r->order[1] == ringorder_lp);
}

## rHasSimpleOrder()

BOOLEAN rHasSimpleOrder | ( | const ring | r | ) |

Definition at line 1893 of file ring.cc.

{
if (r->order[0] == ringorder_unspec) return TRUE;
int blocks = rBlocks(r) - 1;
assume(blocks >= 1);
if (blocks == 1) return TRUE;
int s = 0;
while( (s < blocks) && (r->order[s] == ringorder_IS) && (r->order[blocks-1] == ringorder_IS) )
{
s++;
blocks--;
}
if ((blocks - s) > 2) return FALSE;
assume( blocks == s + 2 );
if (
(r->order[s] != ringorder_c)
&& (r->order[s] != ringorder_C)
&& (r->order[s+1] != ringorder_c)
&& (r->order[s+1] != ringorder_C)
)
return FALSE;
if ((r->order[s+1] == ringorder_M)
|| (r->order[s] == ringorder_M))
return FALSE;
return TRUE;
}

## rHasSimpleOrderAA()

BOOLEAN rHasSimpleOrderAA | ( | ring | r | ) |

Definition at line 1992 of file ring.cc.

{
if (r->order[0] == ringorder_unspec) return TRUE;
int blocks = rBlocks(r) - 1;
assume(blocks >= 1);
if (blocks == 1) return TRUE;
int s = 0;
while( (s < blocks) && (r->order[s] == ringorder_IS) && (r->order[blocks-1] == ringorder_IS) )
{
s++;
blocks--;
}
if ((blocks - s) > 3) return FALSE;
// if ((blocks > 3) || (blocks < 2)) return FALSE;
if ((blocks - s) == 3)
{
return (((r->order[s] == ringorder_aa) && (r->order[s+1] != ringorder_M) &&
((r->order[s+2] == ringorder_c) || (r->order[s+2] == ringorder_C))) ||
(((r->order[s] == ringorder_c) || (r->order[s] == ringorder_C)) &&
(r->order[s+1] == ringorder_aa) && (r->order[s+2] != ringorder_M)));
}
else
{
return ((r->order[s] == ringorder_aa) && (r->order[s+1] != ringorder_M));
}
}

## rKillModified_Wp_Ring()

void rKillModified_Wp_Ring | ( | ring | r | ) |

Definition at line 3130 of file ring.cc.

{
rUnComplete(r);
omFree(r->order);
omFree(r->block0);
omFree(r->block1);
omFree(r->wvhdl[0]);
omFree(r->wvhdl);
omFreeBin(r,sip_sring_bin);
}

## rKillModifiedRing()

void rKillModifiedRing | ( | ring | r | ) |

Definition at line 3119 of file ring.cc.

{
r->qideal=NULL;r->idroot=NULL; // was taken from original
rUnComplete(r);
omFree(r->order);
omFree(r->block0);
omFree(r->block1);
omFree(r->wvhdl);
omFreeBin(r,sip_sring_bin);
}

## rMinusVar()

ring rMinusVar | ( | const ring | r,
|  | char * | v )

undo rPlusVar

Definition at line 6024 of file ring.cc.

{
if (r->order[2]!=0)
{
WerrorS("only for rings with an ordering of one block");
return NULL;
}
int p;
if((r->order[0]==ringorder_C)
||(r->order[0]==ringorder_c))
p=1;
else
p=0;
if((r->order[p]!=ringorder_dp)
&& (r->order[p]!=ringorder_Dp)
&& (r->order[p]!=ringorder_lp)
&& (r->order[p]!=ringorder_rp)
&& (r->order[p]!=ringorder_ds)
&& (r->order[p]!=ringorder_Ds)
&& (r->order[p]!=ringorder_ls))
{
WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
return NULL;
}
ring R=rCopy0(r);
int i=R->N-1;
while(i>=0)
{
if (strcmp(R->names[i],v)==0)
{
R->N--;
omFree(R->names[i]);
for(int j=i;j<R->N;j++) R->names[j]=R->names[j+1];
R->names=(char**)omReallocSize(R->names,r->N*sizeof(char_ptr),R->N*sizeof(char_ptr));
}
i--;
}
R->block1[p]=R->N;
rComplete(R,1);
return R;
}
omReallocSize
#define omReallocSize(addr, o_size, size)
Definition omAllocDecl.h:220
char_ptr
char * char_ptr
Definition structs.h:49

## rModifyRing()

ring rModifyRing | ( | ring | r,
|  | BOOLEAN | omit_degree,
|  | BOOLEAN | try_omit_comp,
|  | unsigned long | exp_limit )

< How many induced ordering block do we have?

Definition at line 2758 of file ring.cc.

{
assume (r != NULL );
assume (exp_limit > 1);
BOOLEAN omitted_degree = FALSE;
int bits;
exp_limit=rGetExpSize(exp_limit, bits, r->N);
BOOLEAN need_other_ring = (exp_limit != r->bitmask);
int iNeedInducedOrderingSetup = 0; ///< How many induced ordering block do we have?
int nblocks=rBlocks(r);
rRingOrder_t *order=(rRingOrder_t*)omAlloc0((nblocks+1)*sizeof(rRingOrder_t));
int *block0=(int*)omAlloc0((nblocks+1)*sizeof(int));
int *block1=(int*)omAlloc0((nblocks+1)*sizeof(int));
int **wvhdl=(int**)omAlloc0((nblocks+1)*sizeof(int *));
int i=0;
int j=0; /* i index in r, j index in res */
for( rRingOrder_t r_ord=r->order[i]; (r_ord != (rRingOrder_t)0) && (i < nblocks); j++, r_ord=r->order[++i])
{
BOOLEAN copy_block_index=TRUE;
if (r->block0[i]==r->block1[i])
{
switch(r_ord)
{
case ringorder_wp:
case ringorder_dp:
case ringorder_Wp:
case ringorder_Dp:
r_ord=ringorder_lp;
break;
case ringorder_Ws:
case ringorder_Ds:
case ringorder_ws:
case ringorder_ds:
r_ord=ringorder_ls;
break;
default:
break;
}
}
switch(r_ord)
{
case ringorder_S:
{
#ifndef SING_NDEBUG
Warn("Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
#endif
order[j]=r_ord; /*r->order[i];*/
break;
}
case ringorder_C:
case ringorder_c:
if (!try_omit_comp)
{
order[j]=r_ord; /*r->order[i]*/;
}
else
{
j--;
need_other_ring=TRUE;
try_omit_comp=FALSE;
copy_block_index=FALSE;
}
break;
case ringorder_wp:
case ringorder_dp:
case ringorder_ws:
case ringorder_ds:
if(!omit_degree)
{
order[j]=r_ord; /*r->order[i]*/;
}
else
{
order[j]=ringorder_rs;
need_other_ring=TRUE;
omit_degree=FALSE;
omitted_degree = TRUE;
}
break;
case ringorder_Wp:
case ringorder_Dp:
case ringorder_Ws:
case ringorder_Ds:
if(!omit_degree)
{
order[j]=r_ord; /*r->order[i];*/
}
else
{
order[j]=ringorder_lp;
need_other_ring=TRUE;
omit_degree=FALSE;
omitted_degree = TRUE;
}
break;
case ringorder_IS:
{
if (try_omit_comp)
{
// tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_IS)", i, r_ord
try_omit_comp = FALSE;
}
order[j]=r_ord; /*r->order[i];*/
iNeedInducedOrderingSetup++;
break;
}
case ringorder_s:
{
assume((i == 0) && (j == 0));
if (try_omit_comp)
{
// tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_s)", i, r_ord
try_omit_comp = FALSE;
}
order[j]=r_ord; /*r->order[i];*/
break;
}
default:
order[j]=r_ord; /*r->order[i];*/
break;
}
if (copy_block_index)
{
block0[j]=r->block0[i];
block1[j]=r->block1[i];
wvhdl[j]=r->wvhdl[i];
}
// order[j]=ringorder_no; // done by omAlloc0
}
if(!need_other_ring)
{
omFreeSize(order,(nblocks+1)*sizeof(rRingOrder_t));
omFreeSize(block0,(nblocks+1)*sizeof(int));
omFreeSize(block1,(nblocks+1)*sizeof(int));
omFreeSize(wvhdl,(nblocks+1)*sizeof(int *));
return r;
}
ring res=(ring)omAllocBin(sip_sring_bin);
*res = *r; // includes r->options
#ifdef HAVE_PLURAL
res->GetNC() = NULL;// to re-create it
#endif
// res->qideal, res->idroot ???
res->wvhdl=wvhdl;
res->order=order;
res->block0=block0;
res->block1=block1;
res->bitmask=exp_limit;
res->wanted_maxExp=r->wanted_maxExp;
//int tmpref=r->cf->ref0;
rComplete(res, 1);
//r->cf->ref=tmpref;
// adjust res->pFDeg: if it was changed globally, then
// it must also be changed for new ring
if (r->pFDegOrig != res->pFDegOrig &&
rOrd_is_WeightedDegree_Ordering(r))
{
// still might need adjustment for weighted orderings
// and omit_degree
res->firstwv = r->firstwv;
res->firstBlockEnds = r->firstBlockEnds;
res->pFDeg = res->pFDegOrig = p_WFirstTotalDegree;
}
if (omitted_degree)
res->pLDeg = r->pLDegOrig;
rOptimizeLDeg(res); // also sets res->pLDegOrig
// set syzcomp
if (res->typ != NULL)
{
if( res->typ[0].ord_typ == ro_syz) // "s" Always on [0] place!
{
res->typ[0] = r->typ[0]; // Copy struct!? + setup the same limit!
if (r->typ[0].data.syz.limit > 0)
{
res->typ[0].data.syz.syz_index
= (int*) omAlloc((r->typ[0].data.syz.limit +1)*sizeof(int));
memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
(r->typ[0].data.syz.limit +1)*sizeof(int));
}
}
if( iNeedInducedOrderingSetup > 0 )
{
for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
if( res->typ[i].ord_typ == ro_is ) // Search for suffixes!
{
ideal F = idrHeadR(r->typ[i].data.is.F, r, res); // Copy F from r into res!
assume(
rSetISReference( res,
F, // WILL BE COPIED!
r->typ[i].data.is.limit,
j++
)
);
id_Delete(&F, res);
iNeedInducedOrderingSetup--;
}
} // Process all induced Ordering blocks! ...
}
// the special case: homog (omit_degree) and 1 block rs: that is global:
// it comes from dp
res->OrdSgn=r->OrdSgn;
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, res, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete");
#endif
// cleanup?
// rDelete(res);
// return r;
// just go on..
}
if( rIsSCA(r) )
{
if( !sca_Force(res, scaFirstAltVar(r), scaLastAltVar(r)) )
WarnS("error in sca_Force!");
}
}
#endif
return res;
}
Warn
#define Warn
Definition emacs.cc:77
sca_Force
bool sca_Force(ring rGR, int b, int e)
Definition sca.cc:1159
omAllocBin
#define omAllocBin(bin)
Definition omAllocDecl.h:205
idrHeadR
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
Definition prCopy.cc:156
rSetISReference
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:5176
rOptimizeLDeg
static void rOptimizeLDeg(ring r)
Definition ring.cc:3211
rOrd_is_WeightedDegree_Ordering
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
Definition ring.cc:2087
scaLastAltVar
static short scaLastAltVar(ring r)
Definition sca.h:25
scaFirstAltVar
static short scaFirstAltVar(ring r)
Definition sca.h:18

## rModifyRing_Simple()

ring rModifyRing_Simple | ( | ring | r,
|  | BOOLEAN | ommit_degree,
|  | BOOLEAN | ommit_comp,
|  | unsigned long | exp_limit,
|  | BOOLEAN & | simple )

Definition at line 3053 of file ring.cc.

{
simple=TRUE;
if (!rHasSimpleOrder(r))
{
simple=FALSE; // sorting needed
assume (r != NULL );
assume (exp_limit > 1);
int bits;
exp_limit=rGetExpSize(exp_limit, bits, r->N);
int nblocks=1+(ommit_comp!=0);
rRingOrder_t *order=(rRingOrder_t*)omAlloc0((nblocks+1)*sizeof(rRingOrder_t));
int *block0=(int*)omAlloc0((nblocks+1)*sizeof(int));
int *block1=(int*)omAlloc0((nblocks+1)*sizeof(int));
int **wvhdl=(int**)omAlloc0((nblocks+1)*sizeof(int *));
order[0]=ringorder_lp;
block0[0]=1;
block1[0]=r->N;
if (!ommit_comp)
{
order[1]=ringorder_C;
}
ring res=(ring)omAlloc0Bin(sip_sring_bin);
*res = *r;
#ifdef HAVE_PLURAL
res->GetNC() = NULL;
#endif
// res->qideal, res->idroot ???
res->wvhdl=wvhdl;
res->order=order;
res->block0=block0;
res->block1=block1;
res->bitmask=exp_limit;
res->wanted_maxExp=r->wanted_maxExp;
//int tmpref=r->cf->ref;
rComplete(res, 1);
//r->cf->ref=tmpref;
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, res, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete");
#endif
// cleanup?
// rDelete(res);
// return r;
// just go on..
}
}
#endif
rOptimizeLDeg(res);
return res;
}
return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
}
rModifyRing
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
Definition ring.cc:2758

## rModifyRing_Wp()

ring rModifyRing_Wp | ( | ring | r,
|  | int * | weights )

construct Wp, C ring

Definition at line 3005 of file ring.cc.

{
ring res=(ring)omAlloc0Bin(sip_sring_bin);
*res = *r;
#ifdef HAVE_PLURAL
res->GetNC() = NULL;
#endif
/*weights: entries for 3 blocks: NULL*/
res->wvhdl = (int **)omAlloc0(3 * sizeof(int *));
/*order: Wp,C,0*/
res->order = (rRingOrder_t *) omAlloc(3 * sizeof(rRingOrder_t *));
res->block0 = (int *)omAlloc0(3 * sizeof(int *));
res->block1 = (int *)omAlloc0(3 * sizeof(int *));
/* ringorder Wp for the first block: var 1..r->N */
res->order[0] = ringorder_Wp;
res->block0[0] = 1;
res->block1[0] = r->N;
res->wvhdl[0] = weights;
/* ringorder C for the second block: no vars */
res->order[1] = ringorder_C;
/* the last block: everything is 0 */
res->order[2] = (rRingOrder_t)0;
//int tmpref=r->cf->ref;
rComplete(res, 1);
//r->cf->ref=tmpref;
#ifdef HAVE_PLURAL
if (rIsPluralRing(r))
{
if ( nc_rComplete(r, res, false) ) // no qideal!
{
#ifndef SING_NDEBUG
WarnS("error in nc_rComplete");
#endif
// cleanup?
// rDelete(res);
// return r;
// just go on..
}
}
#endif
return res;
}

## rNChangeSComps()

void rNChangeSComps | ( | int * | currComponents,
|  | long * | currShiftedComponents,
|  | ring | r )

inline static

Definition at line 4459 of file ring.cc.

{
assume(r->typ[1].ord_typ == ro_syzcomp);
r->typ[1].data.syzcomp.ShiftedComponents = currShiftedComponents;
r->typ[1].data.syzcomp.Components = currComponents;
}

## rNGetSComps()

void rNGetSComps | ( | int ** | currComponents,
|  | long ** | currShiftedComponents,
|  | ring | r )

inline static

Definition at line 4467 of file ring.cc.

{
assume(r->typ[1].ord_typ == ro_syzcomp);
*currShiftedComponents = r->typ[1].data.syzcomp.ShiftedComponents;
*currComponents = r->typ[1].data.syzcomp.Components;
}

## rO_Align()

void rO_Align | ( | int & | place,
|  | int & | bitplace )

static

Definition at line 2248 of file ring.cc.

{
// increment place to the next aligned one
// (count as Exponent_t,align as longs)
if (bitplace!=BITS_PER_LONG)
{
place++;
bitplace=BITS_PER_LONG;
}
}

## rO_ISPrefix()

void rO_ISPrefix | ( | int & | place,
|  | int & | bitplace,
|  | int & | prev_ord,
|  | long * | o,
|  | int | N,
|  | int * | v,
|  | sro_ord & | ord_struct )

static

Definition at line 2516 of file ring.cc.

{
if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
rO_Align(place,bitplace);
// since we add something afterwards - it's better to start with anew!?
ord_struct.ord_typ = ro_isTemp;
ord_struct.data.isTemp.start = place;
#ifdef HAVE_OMALLOC
ord_struct.data.isTemp.pVarOffset = (int *)omMemDup(v);
#else
ord_struct.data.isTemp.pVarOffset = (int *)omAlloc((N+1)*sizeof(int));
memcpy(ord_struct.data.isTemp.pVarOffset,v,(N+1)*sizeof(int));
#endif
ord_struct.data.isTemp.suffixpos = -1;
// We will act as rO_Syz on our own!!!
// Here we allocate an exponent as a level placeholder
o[place]= -1;
prev_ord=-1;
place++;
}
sro_ord::ord_typ
ro_typ ord_typ
Definition ring.h:226
sro_ord::data
union sro_ord::@006200034235045362245112336324125006204215012002 data

## rO_ISSuffix()

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 )

static

Definition at line 2539 of file ring.cc.

{
// Let's find previous prefix:
int typ_j = typ_i - 1;
while(typ_j >= 0)
{
if( tmp_typ[typ_j].ord_typ == ro_isTemp)
break;
typ_j --;
}
assume( typ_j >= 0 );
if( typ_j < 0 ) // Found NO prefix!!! :(
return;
assume( tmp_typ[typ_j].ord_typ == ro_isTemp );
// Get saved state:
const int start = tmp_typ[typ_j].data.isTemp.start;
int *pVarOffset = tmp_typ[typ_j].data.isTemp.pVarOffset;
/*
// shift up all blocks
while(typ_j < (typ_i-1))
{
tmp_typ[typ_j] = tmp_typ[typ_j+1];
typ_j++;
}
typ_j = typ_i - 1; // No increment for typ_i
*/
tmp_typ[typ_j].data.isTemp.suffixpos = typ_i;
// Let's keep that dummy for now...
typ_j = typ_i; // the typ to change!
typ_i++; // Just for now...
for( int i = 0; i <= N; i++ ) // Note [0] == component !!! No Skip?
{
// Was i-th variable allocated in between?
if( v[i] != pVarOffset[i] )
{
pVarOffset[i] = v[i]; // Save for later...
v[i] = -1; // Undo!
assume( pVarOffset[i] != -1 );
}
else
pVarOffset[i] = -1; // No change here...
}
if( pVarOffset[0] != -1 )
pVarOffset[0] &= 0x0fff;
sro_ord &ord_struct = tmp_typ[typ_j];
ord_struct.ord_typ = ro_is;
ord_struct.data.is.start = start;
ord_struct.data.is.end = place;
ord_struct.data.is.pVarOffset = pVarOffset;
// What about component???
// if( v[0] != -1 ) // There is a component already...???
// if( o[ v[0] & 0x0fff ] == sgn )
// {
// pVarOffset[0] = -1; // NEVER USED Afterwards...
// return;
// }
// Moreover: we need to allocate the module component (v[0]) here!
if( v[0] == -1) // It's possible that there was module component v0 at the beginning (before prefix)!
{
// Start with a whole long exponent
if( bitplace != BITS_PER_LONG )
rO_Align(place, bitplace);
assume( bitplace == BITS_PER_LONG );
bitplace -= BITS_PER_LONG;
assume(bitplace == 0);
v[0] = place | (bitplace << 24); // Never mind whether pVarOffset[0] > 0!!!
o[place] = sgn; // Singnum for component ordering
prev_ord = sgn;
}
}

## rO_LexVars()

void rO_LexVars | ( | int & | place,
|  | int & | bitplace,
|  | int | start,
|  | int | end,
|  | int & | prev_ord,
|  | long * | o,
|  | int * | v,
|  | int | bits,
|  | int | opt_var )

static

Definition at line 2399 of file ring.cc.

{
// a block of variables v_start..v_end with lex order, ordsgn 1
int k;
int incr=1;
if(prev_ord==-1) rO_Align(place,bitplace);
if (start>end)
{
incr=-1;
}
for(k=start;;k+=incr)
{
bitplace-=bits;
if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
o[place]=1;
v[k]= place | (bitplace << 24);
if (k==end) break;
}
prev_ord=1;
if (opt_var!= -1)
{
assume((opt_var == end+1) ||(opt_var == end-1));
if((opt_var != end+1) &&(opt_var != end-1)) WarnS("hier-2");
int save_bitplace=bitplace;
bitplace-=bits;
if (bitplace < 0)
{
bitplace=save_bitplace;
return;
}
// there is enough space for the optional var
v[opt_var]=place | (bitplace << 24);
}
}

## rO_LexVars_neg()

void rO_LexVars_neg | ( | int & | place,
|  | int & | bitplace,
|  | int | start,
|  | int | end,
|  | int & | prev_ord,
|  | long * | o,
|  | int * | v,
|  | int | bits,
|  | int | opt_var )

static

Definition at line 2436 of file ring.cc.

{
// a block of variables v_start..v_end with lex order, ordsgn -1
int k;
int incr=1;
if(prev_ord==1) rO_Align(place,bitplace);
if (start>end)
{
incr=-1;
}
for(k=start;;k+=incr)
{
bitplace-=bits;
if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
o[place]=-1;
v[k]=place | (bitplace << 24);
if (k==end) break;
}
prev_ord=-1;
// #if 0
if (opt_var!= -1)
{
assume((opt_var == end+1) ||(opt_var == end-1));
if((opt_var != end+1) &&(opt_var != end-1)) WarnS("hier-1");
int save_bitplace=bitplace;
bitplace-=bits;
if (bitplace < 0)
{
bitplace=save_bitplace;
return;
}
// there is enough space for the optional var
v[opt_var]=place | (bitplace << 24);
}
// #endif
}

## rO_Syz()

void rO_Syz | ( | int & | place,
|  | int & | bitplace,
|  | int & | prev_ord,
|  | int | syz_comp,
|  | long * | o,
|  | sro_ord & | ord_struct )

static

Definition at line 2490 of file ring.cc.

{
// ordering is derived from component number
// let's reserve one Exponent_t for it
if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
rO_Align(place,bitplace);
ord_struct.ord_typ=ro_syz;
ord_struct.data.syz.place=place;
ord_struct.data.syz.limit=syz_comp;
if (syz_comp>0)
ord_struct.data.syz.syz_index = (int*) omAlloc0((syz_comp+1)*sizeof(int));
else
ord_struct.data.syz.syz_index = NULL;
ord_struct.data.syz.curr_index = 1;
o[place]= -1;
prev_ord=-1;
place++;
}

## rO_Syzcomp()

void rO_Syzcomp | ( | int & | place,
|  | int & | bitplace,
|  | int & | prev_ord,
|  | long * | o,
|  | sro_ord & | ord_struct )

static

Definition at line 2475 of file ring.cc.

{
// ordering is derived from component number
rO_Align(place,bitplace);
ord_struct.ord_typ=ro_syzcomp;
ord_struct.data.syzcomp.place=place;
ord_struct.data.syzcomp.Components=NULL;
ord_struct.data.syzcomp.ShiftedComponents=NULL;
o[place]=1;
prev_ord=1;
place++;
rO_Align(place,bitplace);
}

## rO_TDegree()

void rO_TDegree | ( | int & | place,
|  | int & | bitplace,
|  | int | start,
|  | int | end,
|  | long * | o,
|  | sro_ord & | ord_struct )

static

Definition at line 2259 of file ring.cc.

{
// degree (aligned) of variables v_start..v_end, ordsgn 1
rO_Align(place,bitplace);
ord_struct.ord_typ=ro_dp;
ord_struct.data.dp.start=start;
ord_struct.data.dp.end=end;
ord_struct.data.dp.place=place;
o[place]=1;
place++;
rO_Align(place,bitplace);
}

## rO_TDegree_neg()

void rO_TDegree_neg | ( | int & | place,
|  | int & | bitplace,
|  | int | start,
|  | int | end,
|  | long * | o,
|  | sro_ord & | ord_struct )

static

Definition at line 2273 of file ring.cc.

{
// degree (aligned) of variables v_start..v_end, ordsgn -1
rO_Align(place,bitplace);
ord_struct.ord_typ=ro_dp;
ord_struct.data.dp.start=start;
ord_struct.data.dp.end=end;
ord_struct.data.dp.place=place;
o[place]=-1;
place++;
rO_Align(place,bitplace);
}

## rO_WDegree()

void rO_WDegree | ( | int & | place,
|  | int & | bitplace,
|  | int | start,
|  | int | end,
|  | long * | o,
|  | sro_ord & | ord_struct,
|  | int * | weights )

static

Definition at line 2287 of file ring.cc.

{
// weighted degree (aligned) of variables v_start..v_end, ordsgn 1
while((start<end) && (weights[0]==0)) { start++; weights++; }
while((start<end) && (weights[end-start]==0)) { end--; }
int i;
int pure_tdeg=1;
for(i=start;i<=end;i++)
{
if(weights[i-start]!=1)
{
pure_tdeg=0;
break;
}
}
if (pure_tdeg)
{
rO_TDegree(place,bitplace,start,end,o,ord_struct);
return;
}
rO_Align(place,bitplace);
ord_struct.ord_typ=ro_wp;
ord_struct.data.wp.start=start;
ord_struct.data.wp.end=end;
ord_struct.data.wp.place=place;
ord_struct.data.wp.weights=weights;
o[place]=1;
place++;
rO_Align(place,bitplace);
for(i=start;i<=end;i++)
{
if(weights[i-start]<0)
{
ord_struct.ord_typ=ro_wp_neg;
break;
}
}
}

## rO_WDegree64()

void rO_WDegree64 | ( | int & | place,
|  | int & | bitplace,
|  | int | start,
|  | int | end,
|  | long * | o,
|  | sro_ord & | ord_struct,
|  | int64 * | weights )

static

Definition at line 2349 of file ring.cc.

{
// weighted degree (aligned) of variables v_start..v_end, ordsgn 1,
// reserved 2 places
rO_Align(place,bitplace);
ord_struct.ord_typ=ro_wp64;
ord_struct.data.wp64.start=start;
ord_struct.data.wp64.end=end;
ord_struct.data.wp64.place=place;
#ifdef HAVE_OMALLOC
ord_struct.data.wp64.weights64=weights;
#else
int l=end-start+1;
ord_struct.data.wp64.weights64=(int64*)omAlloc(l*sizeof(int64));
for(int i=0;i<l;i++) ord_struct.data.wp64.weights64[i]=weights[i];
#endif
o[place]=1;
place++;
o[place]=1;
place++;
rO_Align(place,bitplace);
}

## rO_WDegree_neg()

void rO_WDegree_neg | ( | int & | place,
|  | int & | bitplace,
|  | int | start,
|  | int | end,
|  | long * | o,
|  | sro_ord & | ord_struct,
|  | int * | weights )

static

Definition at line 2373 of file ring.cc.

{
// weighted degree (aligned) of variables v_start..v_end, ordsgn -1
while((start<end) && (weights[0]==0)) { start++; weights++; }
while((start<end) && (weights[end-start]==0)) { end--; }
rO_Align(place,bitplace);
ord_struct.ord_typ=ro_wp;
ord_struct.data.wp.start=start;
ord_struct.data.wp.end=end;
ord_struct.data.wp.place=place;
ord_struct.data.wp.weights=weights;
o[place]=-1;
place++;
rO_Align(place,bitplace);
int i;
for(i=start;i<=end;i++)
{
if(weights[i-start]<0)
{
ord_struct.ord_typ=ro_wp_neg;
break;
}
}
}

## rO_WMDegree()

void rO_WMDegree | ( | int & | place,
|  | int & | bitplace,
|  | int | start,
|  | int | end,
|  | long * | o,
|  | sro_ord & | ord_struct,
|  | int * | weights )

static

Definition at line 2327 of file ring.cc.

{
assume(weights != NULL);
// weighted degree (aligned) of variables v_start..v_end, ordsgn 1
// while((start<end) && (weights[0]==0)) { start++; weights++; }
// while((start<end) && (weights[end-start]==0)) { end--; }
rO_Align(place,bitplace);
ord_struct.ord_typ=ro_am;
ord_struct.data.am.start=start;
ord_struct.data.am.end=end;
ord_struct.data.am.place=place;
ord_struct.data.am.weights=weights;
ord_struct.data.am.weights_m = weights + (end-start+1);
ord_struct.data.am.len_gen=weights[end-start+1];
assume( ord_struct.data.am.weights_m[0] == ord_struct.data.am.len_gen );
o[place]=1;
place++;
rO_Align(place,bitplace);
}

## rOpposite()

ring rOpposite | ( | ring | src | ) |

Definition at line 5425 of file ring.cc.

{
if (src == NULL) return(NULL);
//rChangeCurrRing(src);
#ifdef RDEBUG
rTest(src);
// rWrite(src);
// rDebugPrint(src);
#endif
ring r = rCopy0(src,FALSE);
if (src->qideal != NULL)
{
id_Delete(&(r->qideal), src);
}
// change vars v1..vN -> vN..v1
int i;
int i2 = (rVar(r)-1)/2;
for(i=i2; i>=0; i--)
{
// index: 0..N-1
//Print("ex var names: %d <-> %d\n",i,rOppVar(r,i));
// exchange names
char *p;
p = r->names[rVar(r)-1-i];
r->names[rVar(r)-1-i] = r->names[i];
r->names[i] = p;
}
// i2=(rVar(r)+1)/2;
// for(int i=i2; i>0; i--)
// {
// // index: 1..N
// //Print("ex var places: %d <-> %d\n",i,rVar(r)+1-i);
// // exchange VarOffset
// int t;
// t=r->VarOffset[i];
// r->VarOffset[i]=r->VarOffset[rOppVar(r,i)];
// r->VarOffset[rOppVar(r,i)]=t;
// }
// change names:
// TODO: does this work the same way for Letterplace?
for (i=rVar(r)-1; i>=0; i--)
{
char *p=r->names[i];
if(isupper(*p)) *p = tolower(*p);
else *p = toupper(*p);
}
// change ordering: listing
// change ordering: compare
// for(i=0; i<r->OrdSize; i++)
// {
// int t,tt;
// switch(r->typ[i].ord_typ)
// {
// case ro_dp:
// //
// t=r->typ[i].data.dp.start;
// r->typ[i].data.dp.start=rOppVar(r,r->typ[i].data.dp.end);
// r->typ[i].data.dp.end=rOppVar(r,t);
// break;
// case ro_wp:
// case ro_wp_neg:
// {
// t=r->typ[i].data.wp.start;
// r->typ[i].data.wp.start=rOppVar(r,r->typ[i].data.wp.end);
// r->typ[i].data.wp.end=rOppVar(r,t);
// // invert r->typ[i].data.wp.weights
// rOppWeight(r->typ[i].data.wp.weights,
// r->typ[i].data.wp.end-r->typ[i].data.wp.start);
// break;
// }
// //case ro_wp64:
// case ro_syzcomp:
// case ro_syz:
// WerrorS("not implemented in rOpposite");
// // should not happen
// break;
//
// case ro_cp:
// t=r->typ[i].data.cp.start;
// r->typ[i].data.cp.start=rOppVar(r,r->typ[i].data.cp.end);
// r->typ[i].data.cp.end=rOppVar(r,t);
// break;
// case ro_none:
// default:
// Werror("unknown type in rOpposite(%d)",r->typ[i].ord_typ);
// break;
// }
// }
// Change order/block structures (needed for rPrint, rAdd etc.)
int j=0;
int l=rBlocks(src);
if ( ! rIsLPRing(src) )
{
// ie Plural or commutative
for(i=0; src->order[i]!=0; i++)
{
switch (src->order[i])
{
case ringorder_c: /* c-> c */
case ringorder_C: /* C-> C */
case ringorder_no /*=0*/: /* end-of-block */
r->order[j]=src->order[i];
j++; break;
case ringorder_lp: /* lp -> rp */
r->order[j]=ringorder_rp;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;break;
case ringorder_rp: /* rp -> lp */
r->order[j]=ringorder_lp;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;break;
case ringorder_dp: /* dp -> a(1..1),ls */
{
l=rRealloc1(r,l,j);
r->order[j]=ringorder_a;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
for(int k=r->block0[j]; k<=r->block1[j]; k++)
r->wvhdl[j][k-r->block0[j]]=1;
j++;
r->order[j]=ringorder_ls;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;
break;
}
case ringorder_Dp: /* Dp -> a(1..1),rp */
{
l=rRealloc1(r,l,j);
r->order[j]=ringorder_a;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
for(int k=r->block0[j]; k<=r->block1[j]; k++)
r->wvhdl[j][k-r->block0[j]]=1;
j++;
r->order[j]=ringorder_rp;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;
break;
}
case ringorder_wp: /* wp -> a(...),ls */
{
l=rRealloc1(r,l,j);
r->order[j]=ringorder_a;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
j++;
r->order[j]=ringorder_ls;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;
break;
}
case ringorder_Wp: /* Wp -> a(...),rp */
{
l=rRealloc1(r,l,j);
r->order[j]=ringorder_a;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
j++;
r->order[j]=ringorder_rp;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;
break;
}
case ringorder_M: /* M -> M */
{
r->order[j]=ringorder_M;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
int n=r->block1[j]-r->block0[j];
/* M is a (n+1)x(n+1) matrix */
for (int nn=0; nn<=n; nn++)
{
rOppWeight(&(r->wvhdl[j][nn*(n+1)]), n /*r->block1[j]-r->block0[j]*/);
}
j++;
break;
}
case ringorder_a: /* a(...),ls -> wp/dp */
{
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
if (src->order[i+1]==ringorder_ls)
{
r->order[j]=ringorder_wp;
i++;
//l=rReallocM1(r,l,j);
}
else
{
r->order[j]=ringorder_a;
}
j++;
break;
}
default:
#if 0
// not yet done:
case ringorder_ls:
case ringorder_rs:
case ringorder_ds:
case ringorder_Ds:
case ringorder_ws:
case ringorder_Ws:
case ringorder_am:
case ringorder_a64:
// should not occur:
case ringorder_S:
case ringorder_IS:
case ringorder_s:
case ringorder_aa:
case ringorder_L:
case ringorder_unspec:
#endif
Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
break;
}
}
} /* end if (!rIsLPRing(src)) */
if (rIsLPRing(src))
{
// applies to Letterplace only
// Letterplace conventions: dp<->Dp, lp<->rp
// Wp(v) cannot be converted since wp(v) does not encode a monomial ordering
// (a(w),<) is troublesome and thus postponed
for(i=0; src->order[i]!=0; i++)
{
switch (src->order[i])
{
case ringorder_c: /* c-> c */
case ringorder_C: /* C-> C */
case ringorder_no /*=0*/: /* end-of-block */
r->order[j]=src->order[i];
j++; break;
case ringorder_lp: /* lp -> rp */
r->order[j]=ringorder_rp;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;break;
case ringorder_rp: /* rp -> lp */
r->order[j]=ringorder_lp;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;break;
case ringorder_dp: /* dp -> Dp */
{
r->order[j]=ringorder_Dp;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;break;
}
case ringorder_Dp: /* Dp -> dp*/
{
r->order[j]=ringorder_dp;
r->block0[j]=rOppVar(r, src->block1[i]);
r->block1[j]=rOppVar(r, src->block0[i]);
j++;break;
}
// not clear how to do:
case ringorder_wp:
case ringorder_Wp:
case ringorder_M:
case ringorder_a:
// not yet done:
case ringorder_ls:
case ringorder_rs:
case ringorder_ds:
case ringorder_Ds:
case ringorder_ws:
case ringorder_Ws:
case ringorder_am:
case ringorder_a64:
case ringorder_Ip:
// should not occur:
case ringorder_S:
case ringorder_IS:
case ringorder_s:
case ringorder_aa:
case ringorder_L:
case ringorder_unspec:
Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
break;
}
}
} /* end if (rIsLPRing(src)) */
rComplete(r);
//rChangeCurrRing(r);
#ifdef RDEBUG
rTest(r);
// rWrite(r);
// rDebugPrint(r);
#endif
#ifdef HAVE_PLURAL
// now, we initialize a non-comm structure on r
if (rIsPluralRing(src))
{
// assume( currRing == r);
int *perm = (int *)omAlloc0((rVar(r)+1)*sizeof(int));
int *par_perm = NULL;
nMapFunc nMap = n_SetMap(src->cf,r->cf);
int ni,nj;
for(i=1; i<=r->N; i++)
{
perm[i] = rOppVar(r,i);
}
matrix C = mpNew(rVar(r),rVar(r));
matrix D = mpNew(rVar(r),rVar(r));
for (i=1; i< rVar(r); i++)
{
for (j=i+1; j<=rVar(r); j++)
{
ni = r->N +1 - i;
nj = r->N +1 - j; /* i<j ==> nj < ni */
assume(MATELEM(src->GetNC()->C,i,j) != NULL);
MATELEM(C,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,r, nMap,par_perm,rPar(src));
if(MATELEM(src->GetNC()->D,i,j) != NULL)
MATELEM(D,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,r, nMap,par_perm,rPar(src));
}
}
id_Test((ideal)C, r);
id_Test((ideal)D, r);
if (nc_CallPlural(C, D, NULL, NULL, r, false, false, true, r)) // no qring setup!
WarnS("Error initializing non-commutative multiplication!");
#ifdef RDEBUG
rTest(r);
// rWrite(r);
// rDebugPrint(r);
#endif
assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
}
#endif /* HAVE_PLURAL */
/* now oppose the qideal for qrings */
if (src->qideal != NULL)
{
#ifdef HAVE_PLURAL
r->qideal = idOppose(src, src->qideal, r); // into the currRing: r
#else
r->qideal = id_Copy(src->qideal, r); // ?
#endif
#ifdef HAVE_PLURAL
if( rIsPluralRing(r) )
{
nc_SetupQuotient(r);
#ifdef RDEBUG
rTest(r);
// rWrite(r);
// rDebugPrint(r);
#endif
}
#endif
}
#ifdef HAVE_PLURAL
if( rIsPluralRing(r) )
assume( ncRingType(r) == ncRingType(src) );
#endif
rTest(r);
return r;
}
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
id_Copy
ideal id_Copy(ideal h1, const ring r)
copy an ideal
Definition simpleideals.cc:542
idOppose
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
Definition old.gring.cc:3363
p_PermPoly
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:4256
rOppVar
#define rOppVar(R, I)
Definition ring.cc:5422
rSimpleOrdStr
const char * rSimpleOrdStr(int ord)
Definition ring.cc:78
rOppWeight
static void rOppWeight(int *w, int l)
Definition ring.cc:5409
rRealloc1
static int rRealloc1(ring r, int size, int pos)
Definition ring.cc:5386
rPar
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:605
rIsLPRing
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:417
ringorder_L
@ ringorder_L
Definition ring.h:91

## rOppWeight()

void rOppWeight | ( | int * | w,
|  | int | l )

static

Definition at line 5409 of file ring.cc.

{
/* works for commutative/Plural; need to be changed for Letterplace */
/* Letterpace: each block of vars needs to be reverted on it own */
int i2=(l+1)/2;
for(int j=0; j<=i2; j++)
{
int t=w[j];
w[j]=w[l-j];
w[l-j]=t;
}
}

## rOptimizeLDeg()

void rOptimizeLDeg | ( | ring | r | ) |

static

Definition at line 3211 of file ring.cc.

{
if (r->pFDeg == p_Deg)
{
if (r->pLDeg == pLDeg1)
r->pLDeg = pLDeg1_Deg;
if (r->pLDeg == pLDeg1c)
r->pLDeg = pLDeg1c_Deg;
}
else if (r->pFDeg == p_Totaldegree)
{
if (r->pLDeg == pLDeg1)
r->pLDeg = pLDeg1_Totaldegree;
if (r->pLDeg == pLDeg1c)
r->pLDeg = pLDeg1c_Totaldegree;
}
else if (r->pFDeg == p_WFirstTotalDegree)
{
if (r->pLDeg == pLDeg1)
r->pLDeg = pLDeg1_WFirstTotalDegree;
if (r->pLDeg == pLDeg1c)
r->pLDeg = pLDeg1c_WFirstTotalDegree;
}
r->pLDegOrig = r->pLDeg;
if (r->pFDeg == p_WTotaldegree)
{ // only c,C,dp,lp,rp: use p_Totaldegree
int i=0;
loop
{
if ((r->order[i]!=ringorder_c)
&& (r->order[i]!=ringorder_C)
&& (r->order[i]!=ringorder_lp)
&& (r->order[i]!=ringorder_rp)
&& (r->order[i]!=ringorder_dp)
&& (r->order[i]!=ringorder_Dp))
return;
i++;
if (r->order[i]==0) break;
}
r->pFDeg = p_Totaldegree;
}
}
pLDeg1_Totaldegree
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
Definition p_polys.cc:976
pLDeg1_WFirstTotalDegree
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
Definition p_polys.cc:1039
pLDeg1c_WFirstTotalDegree
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
Definition p_polys.cc:1069
pLDeg1c_Deg
long pLDeg1c_Deg(poly p, int *l, const ring r)
Definition p_polys.cc:942
pLDeg1
long pLDeg1(poly p, int *l, const ring r)
Definition p_polys.cc:842
pLDeg1_Deg
long pLDeg1_Deg(poly p, int *l, const ring r)
Definition p_polys.cc:911
pLDeg1c
long pLDeg1c(poly p, int *l, const ring r)
Definition p_polys.cc:878
pLDeg1c_Totaldegree
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
Definition p_polys.cc:1006

## rOrd_is_dp()

BOOLEAN rOrd_is_dp | ( | const ring | r | ) |

Definition at line 2056 of file ring.cc.

{
int ord=0;
if ((r->order[0]==ringorder_C)||(r->order[0]==ringorder_c)) ord=1;
return ((rVar(r) > 1) &&
(r->order[ord]==ringorder_dp)
&&(r->block0[ord]==1)
&&(r->block1[ord]==r->N));
}

## rOrd_is_Ds()

BOOLEAN rOrd_is_Ds | ( | const ring | r | ) |

Definition at line 2076 of file ring.cc.

{
int ord=0;
if ((r->order[0]==ringorder_C)||(r->order[0]==ringorder_c)) ord=1;
return ((rVar(r) > 1) &&
(r->order[ord]==ringorder_Ds)
&&(r->block0[ord]==1)
&&(r->block1[ord]==r->N));
}

## rOrd_is_ds()

BOOLEAN rOrd_is_ds | ( | const ring | r | ) |

Definition at line 2066 of file ring.cc.

{
int ord=0;
if ((r->order[0]==ringorder_C)||(r->order[0]==ringorder_c)) ord=1;
return ((rVar(r) > 1) &&
(r->order[ord]==ringorder_ds)
&&(r->block0[ord]==1)
&&(r->block1[ord]==r->N));
}

## rOrd_is_MixedDegree_Ordering()

BOOLEAN rOrd_is_MixedDegree_Ordering | ( | ring | r | ) |

Definition at line 3505 of file ring.cc.

{
int i;
poly p=p_One(r);
p_SetExp(p,1,1,r);
p_Setm(p,r);
int vz=sign(p_FDeg(p,r));
for(i=2;i<=rVar(r);i++)
{
p_SetExp(p,i-1,0,r);
p_SetExp(p,i,1,r);
p_Setm(p,r);
if (sign(p_FDeg(p,r))!=vz)
{
p_Delete(&p,r);
return TRUE;
}
}
p_Delete(&p,r);
return FALSE;
}
p_FDeg
static long p_FDeg(const poly p, const ring r)
Definition p_polys.h:382
sign
static int sign(int x)
Definition ring.cc:3504

## rOrd_is_Totaldegree_Ordering()

BOOLEAN rOrd_is_Totaldegree_Ordering | ( | const ring | r | ) |

Definition at line 2043 of file ring.cc.

{
// Hmm.... what about Syz orderings?
return ((rVar(r) > 1) &&
((rHasSimpleOrder(r) &&
((rOrder_is_DegOrdering((rRingOrder_t)r->order[0]) ||
rOrder_is_DegOrdering(( rRingOrder_t)r->order[1])))) ||
((rHasSimpleOrderAA(r) &&
(rOrder_is_DegOrdering((rRingOrder_t)r->order[1]) ||
((r->order[1]!=0) &&
rOrder_is_DegOrdering((rRingOrder_t)r->order[2])))))));
}
rOrder_is_DegOrdering
BOOLEAN rOrder_is_DegOrdering(const rRingOrder_t order)
Definition ring.cc:1958
rHasSimpleOrderAA
BOOLEAN rHasSimpleOrderAA(ring r)
Definition ring.cc:1992

## rOrd_is_WeightedDegree_Ordering()

BOOLEAN rOrd_is_WeightedDegree_Ordering | ( | const ring | r | ) |

Definition at line 2087 of file ring.cc.

{
// Hmm.... what about Syz orderings?
return ((rVar(r) > 1) &&
rHasSimpleOrder(r) &&
(rOrder_is_WeightedOrdering((rRingOrder_t)r->order[0]) ||
rOrder_is_WeightedOrdering(( rRingOrder_t)r->order[1])));
}
rOrder_is_WeightedOrdering
BOOLEAN rOrder_is_WeightedOrdering(rRingOrder_t order)
Definition ring.cc:1977

## rOrd_SetCompRequiresSetm()

BOOLEAN rOrd_SetCompRequiresSetm | ( | const ring | r | ) |

return TRUE if p_SetComp requires p_Setm

Definition at line 2023 of file ring.cc.

{
if (r->typ != NULL)
{
int pos;
for (pos=0;pos<r->OrdSize;pos++)
{
sro_ord* o=&(r->typ[pos]);
if ( (o->ord_typ == ro_syzcomp)
|| (o->ord_typ == ro_syz)
|| (o->ord_typ == ro_is)
|| (o->ord_typ == ro_am)
|| (o->ord_typ == ro_isTemp))
return TRUE;
}
}
return FALSE;
}

## rOrder_is_DegOrdering()

BOOLEAN rOrder_is_DegOrdering | ( | const rRingOrder_t | order | ) |

Definition at line 1958 of file ring.cc.

{
switch(order)
{
case ringorder_dp:
case ringorder_Dp:
case ringorder_ds:
case ringorder_Ds:
case ringorder_Ws:
case ringorder_Wp:
case ringorder_ws:
case ringorder_wp:
return TRUE;
default:
return FALSE;
}
}

## rOrder_is_WeightedOrdering()

BOOLEAN rOrder_is_WeightedOrdering | ( | rRingOrder_t | order | ) |

Definition at line 1977 of file ring.cc.

{
switch(order)
{
case ringorder_Ws:
case ringorder_Wp:
case ringorder_ws:
case ringorder_wp:
return TRUE;
default:
return FALSE;
}
}

## rOrderName()

rRingOrder_t rOrderName | ( | char * | ordername | ) |

Definition at line 512 of file ring.cc.

{
int order=ringorder_unspec;
while (order!= 0)
{
if (strcmp(ordername,rSimpleOrdStr(order))==0)
break;
order--;
}
if (order==0) Werror("wrong ring order `%s`",ordername);
omFree((ADDRESS)ordername);
return (rRingOrder_t)order;
}

## rOrdStr()

char * rOrdStr | ( | ring | r | ) |

Definition at line 526 of file ring.cc.

{
if ((r==NULL)||(r->order==NULL)) return omStrDup("");
int nblocks,l,i;
for (nblocks=0; r->order[nblocks]; nblocks++);
nblocks--;
StringSetS("");
for (l=0; ; l++)
{
StringAppendS((char *)rSimpleOrdStr(r->order[l]));
if (r->order[l] == ringorder_s)
{
StringAppend("(%d)",r->block0[l]);
}
else if (
(r->order[l] != ringorder_c)
&& (r->order[l] != ringorder_C)
&& (r->order[l] != ringorder_s)
&& (r->order[l] != ringorder_S)
&& (r->order[l] != ringorder_IS)
)
{
if (r->wvhdl[l]!=NULL)
{
#ifndef SING_NDEBUG
if((r->order[l] != ringorder_wp)
&&(r->order[l] != ringorder_Wp)
&&(r->order[l] != ringorder_ws)
&&(r->order[l] != ringorder_Ws)
&&(r->order[l] != ringorder_a)
&&(r->order[l] != ringorder_a64)
&&(r->order[l] != ringorder_am)
&&(r->order[l] != ringorder_M))
{
Warn("should not have wvhdl entry at pos. %d",l);
StringAppend("(%d)",r->block1[l]-r->block0[l]+1);
}
else
#endif
{
StringAppendS("(");
for (int j= 0;
j<(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1);
j+=i+1)
{
char c=',';
if(r->order[l]==ringorder_a64)
{
int64 * w=(int64 *)r->wvhdl[l];
for (i = 0; i<r->block1[l]-r->block0[l]; i++)
{
StringAppend("%lld," ,w[i]);
}
StringAppend("%lld)" ,w[i]);
break;
}
else
{
for (i = 0; i<r->block1[l]-r->block0[l]; i++)
{
StringAppend("%d," ,r->wvhdl[l][i+j]);
}
}
if (r->order[l]!=ringorder_M)
{
StringAppend("%d)" ,r->wvhdl[l][i+j]);
break;
}
if (j+i+1==(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1))
c=')';
StringAppend("%d%c" ,r->wvhdl[l][i+j],c);
}
}
}
else
StringAppend("(%d)",r->block1[l]-r->block0[l]+1);
}
else if (r->order[l] == ringorder_IS)
{
assume( r->block0[l] == r->block1[l] );
const int s = r->block0[l];
assume( (-2 < s) && (s < 2) );
StringAppend("(%d)", s);
}
if (l==nblocks)
{
if (r->wanted_maxExp!=0)
{
long mm=r->wanted_maxExp;
if (mm>MAX_INT_VAL) mm=MAX_INT_VAL;
StringAppend(",L(%ld)",mm);
}
return StringEndS();
}
StringAppendS(",");
}
}
StringAppend
#define StringAppend
Definition emacs.cc:79
MAX_INT_VAL
const int MAX_INT_VAL
Definition mylimits.h:12
StringSetS
void StringSetS(const char *st)
Definition reporter.cc:128
StringAppendS
void StringAppendS(const char *st)
Definition reporter.cc:107
StringEndS
char * StringEndS()
Definition reporter.cc:151

## rParStr()

char * rParStr | ( | ring | r | ) |

Definition at line 654 of file ring.cc.

{
if ((r==NULL)||(rParameter(r)==NULL)) return omStrDup("");
char const * const * const params = rParameter(r);
int i;
int l=2;
for (i=0; i<rPar(r); i++)
{
l+=strlen(params[i])+1;
}
char *s=(char *)omAlloc((long)l);
s[0]='\0';
for (i=0; i<rPar(r)-1; i++)
{
strcat(s, params[i]);
strcat(s,",");
}
strcat(s, params[i]);
return s;
}
rParameter
static char const ** rParameter(const ring r)
(r->cf->parameter)
Definition ring.h:631

## rPlusVar()

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

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

Definition at line 5942 of file ring.cc.

{
if (r->order[2]!=0)
{
WerrorS("only for rings with an ordering of one block");
return NULL;
}
int p;
if((r->order[0]==ringorder_C)
||(r->order[0]==ringorder_c))
p=1;
else
p=0;
if((r->order[p]!=ringorder_dp)
&& (r->order[p]!=ringorder_Dp)
&& (r->order[p]!=ringorder_lp)
&& (r->order[p]!=ringorder_rp)
&& (r->order[p]!=ringorder_ds)
&& (r->order[p]!=ringorder_Ds)
&& (r->order[p]!=ringorder_ls))
{
WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
return NULL;
}
for(int i=r->N-1;i>=0;i--)
{
if (strcmp(r->names[i],v)==0)
{
Werror("duplicate variable name >>%s<<",v);
return NULL;
}
}
ring R=rCopy0(r);
char **names;
#ifdef HAVE_SHIFTBBA
if (rIsLPRing(r))
{
R->isLPring=r->isLPring+1;
R->N=((r->N)/r->isLPring)+r->N;
names=(char**)omAlloc(R->N*sizeof(char_ptr));
if (left)
{
for(int b=0;b<((r->N)/r->isLPring);b++)
{
names[b*R->isLPring]=omStrDup(v);
for(int i=R->isLPring-1;i>0;i--)
names[i+b*R->isLPring]=R->names[i-1+b*r->isLPring];
}
}
else
{
for(int b=0;b<((r->N)/r->isLPring);b++)
{
names[(b+1)*R->isLPring-1]=omStrDup(v);
for(int i=R->isLPring-2;i>=0;i--)
names[i+b*R->isLPring]=R->names[i+b*r->isLPring];
}
}
}
else
#endif
{
R->N++;
names=(char**)omAlloc(R->N*sizeof(char_ptr));
if (left)
{
names[0]=omStrDup(v);
for(int i=R->N-1;i>0;i--) names[i]=R->names[i-1];
}
else
{
names[R->N-1]=omStrDup(v);
for(int i=R->N-2;i>=0;i--) names[i]=R->names[i];
}
}
omFreeSize(R->names,r->N*sizeof(char_ptr));
R->names=names;
R->block1[p]=R->N;
rComplete(R);
return R;
}

## rRealloc1()

int rRealloc1 | ( | ring | r,
|  | int | size,
|  | int | pos )

static

Definition at line 5386 of file ring.cc.

{
r->order=(rRingOrder_t*)omReallocSize(r->order, size*sizeof(rRingOrder_t), (size+1)*sizeof(rRingOrder_t));
r->block0=(int*)omReallocSize(r->block0, size*sizeof(int), (size+1)*sizeof(int));
r->block1=(int*)omReallocSize(r->block1, size*sizeof(int), (size+1)*sizeof(int));
r->wvhdl=(int **)omReallocSize(r->wvhdl,size*sizeof(int *), (size+1)*sizeof(int *));
for(int k=size; k>pos; k--) r->wvhdl[k]=r->wvhdl[k-1];
r->order[size]=(rRingOrder_t)0;
size++;
return size;
}
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition cf_ops.cc:600

## rRightAdjustVarOffset()

void rRightAdjustVarOffset | ( | ring | r | ) |

static

right-adjust r->VarOffset

Definition at line 4174 of file ring.cc.

{
int* shifts = (int*) omAlloc(r->ExpL_Size*sizeof(int));
int i;
// initialize shifts
for (i=0;i<r->ExpL_Size;i++)
shifts[i] = BIT_SIZEOF_LONG;
// find minimal bit shift in each long exp entry
for (i=1;i<=r->N;i++)
{
if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
shifts[r->VarOffset[i] & 0xffffff] = r->VarOffset[i] >> 24;
}
// reset r->VarOffset: set the minimal shift to 0
for (i=1;i<=r->N;i++)
{
if (shifts[r->VarOffset[i] & 0xffffff] != 0)
r->VarOffset[i]
= (r->VarOffset[i] & 0xffffff) |
(((r->VarOffset[i] >> 24) - shifts[r->VarOffset[i] & 0xffffff]) << 24);
}
omFree(shifts);
}

## rRing_has_CompLastBlock()

BOOLEAN rRing_has_CompLastBlock | ( | const ring | r | ) |

Definition at line 5329 of file ring.cc.

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

## rRing_ord_pure_Dp()

BOOLEAN rRing_ord_pure_Dp | ( | const ring | r | ) |

Definition at line 5346 of file ring.cc.

{
if ((r->order[0]==ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
return TRUE;
if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
&& ((r->order[1]==ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
return TRUE;
return FALSE;
}

## rRing_ord_pure_dp()

BOOLEAN rRing_ord_pure_dp | ( | const ring | r | ) |

Definition at line 5336 of file ring.cc.

{
if ((r->order[0]==ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
return TRUE;
if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
&& ((r->order[1]==ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
return TRUE;
return FALSE;
}

## rRing_ord_pure_lp()

BOOLEAN rRing_ord_pure_lp | ( | const ring | r | ) |

Definition at line 5356 of file ring.cc.

{
if ((r->order[0]==ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
return TRUE;
if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
&& ((r->order[1]==ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
return TRUE;
return FALSE;
}

## 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 1805 of file ring.cc.

{
int i, j;
if (r1 == r2) return TRUE;
if (r1 == NULL || r2 == NULL) return FALSE;
if ((r1->cf != r2->cf)
|| (rVar(r1) != rVar(r2))
|| (r1->OrdSgn != r2->OrdSgn))
return FALSE;
i=0;
while (r1->order[i] != 0)
{
if (r2->order[i] == 0) return FALSE;
if ((r1->order[i] != r2->order[i])
|| (r1->block0[i] != r2->block0[i])
|| (r1->block1[i] != r2->block1[i]))
return FALSE;
if (r1->wvhdl[i] != NULL)
{
if (r2->wvhdl[i] == NULL)
return FALSE;
for (j=0; j<r1->block1[i]-r1->block0[i]+1; j++)
if (r2->wvhdl[i][j] != r1->wvhdl[i][j])
return FALSE;
}
else if (r2->wvhdl[i] != NULL) return FALSE;
i++;
}
if (r2->order[i] != 0) return FALSE;
// we do not check variable names
// we do not check minpoly/minideal
// we do not check qideal
return TRUE;
}

## rSetDegStuff()

void rSetDegStuff | ( | ring | r | ) |

static

Definition at line 3255 of file ring.cc.

{
rRingOrder_t* order = r->order;
int* block0 = r->block0;
int* block1 = r->block1;
int** wvhdl = r->wvhdl;
if (order[0]==ringorder_S ||order[0]==ringorder_s || order[0]==ringorder_IS)
{
order++;
block0++;
block1++;
wvhdl++;
}
r->LexOrder = FALSE;
r->pFDeg = p_Totaldegree;
r->pLDeg = (r->OrdSgn == 1 ? pLDegb : pLDeg0);
/*======== ordering type is (am,_) ==================*/
if (order[0]==ringorder_am)
{
for(int ii=block0[0];ii<=block1[0];ii++)
if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
r->LexOrder=FALSE;
for(int ii=block0[0];ii<=block1[0];ii++)
if (wvhdl[0][ii-1]==0) { r->LexOrder=TRUE;break;}
if ((block0[0]==1)&&(block1[0]==r->N))
{
r->pFDeg = p_Deg;
r->pLDeg = pLDeg1c_Deg;
}
else
{
r->pFDeg = p_WTotaldegree;
r->LexOrder=TRUE;
r->pLDeg = pLDeg1c_WFirstTotalDegree;
}
r->firstwv = wvhdl[0];
}
/*======== ordering type is (_,c) =========================*/
else if ((order[0]==ringorder_unspec) || (order[1] == 0)
||(
((order[1]==ringorder_c)||(order[1]==ringorder_C)
||(order[1]==ringorder_S)
||(order[1]==ringorder_s))
&& (order[0]!=ringorder_M)
&& (order[2]==0))
)
{
if (r->OrdSgn == -1) r->pLDeg = pLDeg0c;
if ((order[0] == ringorder_lp)
|| (order[0] == ringorder_ls)
|| (order[0] == ringorder_rp)
|| (order[0] == ringorder_rs))
{
r->LexOrder=TRUE;
r->pLDeg = pLDeg1c;
r->pFDeg = p_Totaldegree;
}
else if ((order[0] == ringorder_a)
|| (order[0] == ringorder_wp)
|| (order[0] == ringorder_Wp))
{
r->pFDeg = p_WFirstTotalDegree;
}
else if ((order[0] == ringorder_ws)
|| (order[0] == ringorder_Ws))
{
for(int ii=block0[0];ii<=block1[0];ii++)
{
if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
}
if (r->MixedOrder==0)
{
if ((block0[0]==1)&&(block1[0]==r->N))
r->pFDeg = p_WTotaldegree;
else
r->pFDeg = p_WFirstTotalDegree;
}
else
r->pFDeg = p_Totaldegree;
}
r->firstBlockEnds=block1[0];
r->firstwv = wvhdl[0];
}
/*======== ordering type is (c,_) =========================*/
else if (((order[0]==ringorder_c)
||(order[0]==ringorder_C)
||(order[0]==ringorder_S)
||(order[0]==ringorder_s))
&& (order[1]!=ringorder_M)
&& (order[2]==0))
{
if ((order[1] == ringorder_lp)
|| (order[1] == ringorder_ls)
|| (order[1] == ringorder_rp)
|| order[1] == ringorder_rs)
{
r->LexOrder=TRUE;
r->pLDeg = pLDeg1c;
r->pFDeg = p_Totaldegree;
}
r->firstBlockEnds=block1[1];
if (wvhdl!=NULL) r->firstwv = wvhdl[1];
if ((order[1] == ringorder_a)
|| (order[1] == ringorder_wp)
|| (order[1] == ringorder_Wp))
r->pFDeg = p_WFirstTotalDegree;
else if ((order[1] == ringorder_ws)
|| (order[1] == ringorder_Ws))
{
for(int ii=block0[1];ii<=block1[1];ii++)
if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;break;}
if (r->MixedOrder==FALSE)
r->pFDeg = p_WFirstTotalDegree;
else
r->pFDeg = p_Totaldegree;
}
}
/*------- more than one block ----------------------*/
else
{
if ((r->VectorOut)||(order[0]==ringorder_C)||(order[0]==ringorder_S)||(order[0]==ringorder_s))
{
rSetFirstWv(r, 1, order, block0, block1, wvhdl);
}
else
rSetFirstWv(r, 0, order, block0, block1, wvhdl);
if ((order[0]!=ringorder_c)
&& (order[0]!=ringorder_C)
&& (order[0]!=ringorder_S)
&& (order[0]!=ringorder_s))
{
r->pLDeg = pLDeg1c;
}
else
{
r->pLDeg = pLDeg1;
}
r->pFDeg = p_WTotaldegree; // may be improved: p_Totaldegree for lp/dp/ls/.. blocks
}
if (rOrd_is_Totaldegree_Ordering(r)
|| rOrd_is_WeightedDegree_Ordering(r))
{
if(r->MixedOrder==FALSE)
r->pFDeg = p_Deg;
else
r->pFDeg = p_Totaldegree;
}
if( rGetISPos(0, r) != -1 ) // Are there Schreyer induced blocks?
{
#ifndef SING_NDEBUG
assume( r->pFDeg == p_Deg || r->pFDeg == p_WTotaldegree || r->pFDeg == p_Totaldegree);
#endif
r->pLDeg = pLDeg1; // ?
}
r->pFDegOrig = r->pFDeg;
// NOTE: this leads to wrong ecart during std
// in Old/sre.tst
rOptimizeLDeg(r); // also sets r->pLDegOrig
}
pLDegb
long pLDegb(poly p, int *l, const ring r)
Definition p_polys.cc:812
pLDeg0c
long pLDeg0c(poly p, int *l, const ring r)
Definition p_polys.cc:771
pLDeg0
long pLDeg0(poly p, int *l, const ring r)
Definition p_polys.cc:740
rGetISPos
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:5144
rOrd_is_Totaldegree_Ordering
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
Definition ring.cc:2043
rSetFirstWv
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
Definition ring.cc:3179

## rSetFirstWv()

void rSetFirstWv | ( | ring | r,
|  | int | i,
|  | rRingOrder_t * | order,
|  | int * | block0,
|  | int * | block1,
|  | int ** | wvhdl )

static

Definition at line 3179 of file ring.cc.

{
// cheat for ringorder_aa
if (order[i] == ringorder_aa)
i++;
if(block1[i]!=r->N) r->LexOrder=TRUE;
r->firstBlockEnds=block1[i];
r->firstwv = wvhdl[i];
if ((order[i]== ringorder_ws)
|| (order[i]==ringorder_Ws)
|| (order[i]== ringorder_wp)
|| (order[i]==ringorder_Wp)
|| (order[i]== ringorder_a)
/*|| (order[i]==ringorder_A)*/)
{
int j;
for(j=block1[i]-block0[i];j>=0;j--)
{
if (r->firstwv[j]==0) r->LexOrder=TRUE;
}
}
else if (order[i]==ringorder_a64)
{
int j;
int64 *w=rGetWeightVec(r);
for(j=block1[i]-block0[i];j>=0;j--)
{
if (w[j]==0) r->LexOrder=TRUE;
}
}
}
rGetWeightVec
int64 * rGetWeightVec(const ring r)
Definition ring.cc:5366

## rSetISReference()

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

Definition at line 5176 of file ring.cc.

{
// Put the reference set F into the ring -ordering -recor
if (r->typ==NULL)
{
dReportError("Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
return FALSE;
}
int pos = rGetISPos(p, r);
if( pos == -1 )
{
dReportError("Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
return FALSE;
}
#if MYTEST
if( i != r->typ[pos].data.is.limit )
Print("Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
#endif
const ideal FF = idrHeadR(F, r, r); // id_Copy(F, r); // ???
if( r->typ[pos].data.is.F != NULL)
{
#if MYTEST
PrintS("Deleting old reference set F... \n"); // idShow(r->typ[pos].data.is.F, r); PrintLn();
#endif
id_Delete(&r->typ[pos].data.is.F, r);
r->typ[pos].data.is.F = NULL;
}
assume(r->typ[pos].data.is.F == NULL);
r->typ[pos].data.is.F = FF; // F is owened by ring now! TODO: delete at the end!
r->typ[pos].data.is.limit = i; // First induced component
#if MYTEST
PrintS("New reference set FF : \n"); idShow(FF, r, r, 1); PrintLn();
#endif
return TRUE;
}
idShow
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
Definition simpleideals.cc:57

## rSetNegWeight()

void rSetNegWeight | ( | ring | r | ) |

static

Definition at line 3425 of file ring.cc.

{
int i,l;
if (r->typ!=NULL)
{
l=0;
for(i=0;i<r->OrdSize;i++)
{
if((r->typ[i].ord_typ==ro_wp_neg)
||(r->typ[i].ord_typ==ro_am))
l++;
}
if (l>0)
{
r->NegWeightL_Size=l;
r->NegWeightL_Offset=(int *) omAlloc(l*sizeof(int));
l=0;
for(i=0;i<r->OrdSize;i++)
{
if(r->typ[i].ord_typ==ro_wp_neg)
{
r->NegWeightL_Offset[l]=r->typ[i].data.wp.place;
l++;
}
else if(r->typ[i].ord_typ==ro_am)
{
r->NegWeightL_Offset[l]=r->typ[i].data.am.place;
l++;
}
}
return;
}
}
r->NegWeightL_Size = 0;
r->NegWeightL_Offset = NULL;
}

## rSetOption()

void rSetOption | ( | ring | r | ) |

static

Definition at line 3462 of file ring.cc.

{
// set redthrough
if (!TEST_OPT_OLDSTD && r->OrdSgn == 1 && ! r->LexOrder)
r->options |= Sy_bit(OPT_REDTHROUGH);
else
r->options &= ~Sy_bit(OPT_REDTHROUGH);
// set intStrategy
if ( (r->cf->extRing!=NULL)
|| rField_is_Q(r)
|| rField_is_Ring(r)
|| (((int)getCoeffType(r->cf))>16) /* OSCAR types*/
)
r->options |= Sy_bit(OPT_INTSTRATEGY);
else
r->options &= ~Sy_bit(OPT_INTSTRATEGY);
// set redTail
if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=NULL))
r->options &= ~Sy_bit(OPT_REDTAIL);
else
r->options |= Sy_bit(OPT_REDTAIL);
}
OPT_INTSTRATEGY
#define OPT_INTSTRATEGY
Definition options.h:93
OPT_REDTAIL
#define OPT_REDTAIL
Definition options.h:92
TEST_OPT_OLDSTD
#define TEST_OPT_OLDSTD
Definition options.h:125
OPT_REDTHROUGH
#define OPT_REDTHROUGH
Definition options.h:83
Sy_bit
#define Sy_bit(x)
Definition options.h:31
rField_is_Q
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:512
rField_is_Ring
#define rField_is_Ring(R)
Definition ring.h:491

## rSetOutParams()

void rSetOutParams | ( | ring | r | ) |

static

Definition at line 3141 of file ring.cc.

{
r->VectorOut = (r->order[0] == ringorder_c);
if (rIsNCRing(r))
r->CanShortOut=FALSE;
else
{
r->CanShortOut = TRUE;
int i;
if (rParameter(r)!=NULL)
{
for (i=0;i<rPar(r);i++)
{
if(strlen(rParameter(r)[i])>1)
{
r->CanShortOut=FALSE;
break;
}
}
}
if (r->CanShortOut)
{
int N = r->N;
for (i=(N-1);i>=0;i--)
{
if(r->names[i] != NULL && strlen(r->names[i])>1)
{
r->CanShortOut=FALSE;
break;
}
}
}
}
r->ShortOut = r->CanShortOut;
assume( !( !r->CanShortOut && r->ShortOut ) );
}
rIsNCRing
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:427

## rSetSyzComp()

void rSetSyzComp | ( | int | k,
|  | const ring | r )

Definition at line 5230 of file ring.cc.

{
if(k < 0)
{
dReportError("rSetSyzComp with negative limit!");
return;
}
assume( k >= 0 );
if (TEST_OPT_PROT) Print("{%d}", k);
if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz))
{
r->block0[0]=r->block1[0] = k;
if( k == r->typ[0].data.syz.limit )
return; // nothing to do
int i;
if (r->typ[0].data.syz.limit == 0)
{
r->typ[0].data.syz.syz_index = (int*) omAlloc0((k+1)*sizeof(int));
r->typ[0].data.syz.syz_index[0] = 0;
r->typ[0].data.syz.curr_index = 1;
}
else
{
r->typ[0].data.syz.syz_index = (int*)
omReallocSize(r->typ[0].data.syz.syz_index,
(r->typ[0].data.syz.limit+1)*sizeof(int),
(k+1)*sizeof(int));
}
for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
{
r->typ[0].data.syz.syz_index[i] =
r->typ[0].data.syz.curr_index;
}
if(k < r->typ[0].data.syz.limit) // ?
{
#ifndef SING_NDEBUG
Warn("rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
#endif
r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[k];
}
r->typ[0].data.syz.limit = k;
r->typ[0].data.syz.curr_index++;
}
else if(
(r->typ!=NULL) &&
(r->typ[0].ord_typ==ro_isTemp)
)
{
// (r->typ[currRing->typ[0].data.isTemp.suffixpos].data.is.limit == k)
#ifndef SING_NDEBUG
Warn("rSetSyzComp(%d) in an IS ring! Be careful!", k);
#endif
}
else if (r->order[0]==ringorder_s)
{
r->block0[0] = r->block1[0] = k;
}
else if (r->order[0]!=ringorder_c)
{
dReportError("syzcomp in incompatible ring");
}
#ifdef PDEBUG
EXTERN_VAR int pDBsyzComp;
pDBsyzComp=k;
#endif
}
EXTERN_VAR
#define EXTERN_VAR
Definition globaldefs.h:6
TEST_OPT_PROT
#define TEST_OPT_PROT
Definition options.h:105
pDBsyzComp
VAR int pDBsyzComp
Definition ring.cc:5226

## rSetVarL()

void rSetVarL | ( | ring | r | ) |

static

set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex

Definition at line 4119 of file ring.cc.

{
int min = INT_MAX, min_j = -1;
int* VarL_Number = (int*) omAlloc0(r->ExpL_Size*sizeof(int));
int i,j;
// count how often a var long is occupied by an exponent
for (i=1; i<=r->N; i++)
{
VarL_Number[r->VarOffset[i] & 0xffffff]++;
}
// determine how many and min
for (i=0, j=0; i<r->ExpL_Size; i++)
{
if (VarL_Number[i] != 0)
{
if (min > VarL_Number[i])
{
min = VarL_Number[i];
min_j = j;
}
j++;
}
}
r->VarL_Size = j; // number of long with exp. entries in
// in p->exp
r->VarL_Offset = (int*) omAlloc(r->VarL_Size*sizeof(int));
r->VarL_LowIndex = 0;
// set VarL_Offset
for (i=0, j=0; i<r->ExpL_Size; i++)
{
if (VarL_Number[i] != 0)
{
r->VarL_Offset[j] = i;
if (j > 0 && r->VarL_Offset[j-1] != r->VarL_Offset[j] - 1)
r->VarL_LowIndex = -1;
j++;
}
}
if (r->VarL_LowIndex >= 0)
r->VarL_LowIndex = r->VarL_Offset[0];
if (min_j != 0)
{
j = r->VarL_Offset[min_j];
r->VarL_Offset[min_j] = r->VarL_Offset[0];
r->VarL_Offset[0] = j;
}
omFree(VarL_Number);
}
min
static int min(int a, int b)
Definition fast_mult.cc:268

## rSetWeightVec()

void rSetWeightVec | ( | ring | r,
|  | int64 * | wv )

Definition at line 5376 of file ring.cc.

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

## rSimpleOrdStr()

const char * rSimpleOrdStr | ( | int | ord | ) |

Definition at line 78 of file ring.cc.

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

## rString()

char * rString | ( | ring | r | ) |

Definition at line 678 of file ring.cc.

{
if ((r!=NULL)&&(r->cf!=NULL))
{
char *ch=rCharStr(r);
char *var=rVarStr(r);
char *ord=rOrdStr(r);
int len=strlen(ch)+strlen(var)+strlen(ord)+9;
char *res=(char *)omAlloc(len);
snprintf(res,len,"(%s),(%s),(%s)",ch,var,ord);
omFree((ADDRESS)ch);
omFree((ADDRESS)var);
omFree((ADDRESS)ord);
return res;
}
else
return omStrDup("undefined");
}
rCharStr
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition ring.cc:652
rOrdStr
char * rOrdStr(ring r)
Definition ring.cc:526
rVarStr
char * rVarStr(ring r)
Definition ring.cc:628

## rSum()

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

Definition at line 1408 of file ring.cc.

{
if ((r1==NULL)||(r2==NULL)
||(r1->cf==NULL)||(r2->cf==NULL))
return -1;
if (r1==r2)
{
sum=r1;
rIncRefCnt(r1);
return 0;
}
return rSumInternal(r1,r2,sum,TRUE,FALSE);
}
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,...
Definition ring.cc:755
rIncRefCnt
static ring rIncRefCnt(ring r)
Definition ring.h:849

## 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 755 of file ring.cc.

{
ip_sring tmpR;
memset(&tmpR,0,sizeof(tmpR));
/* check coeff. field =====================================================*/
if (r1->cf==r2->cf)
{
tmpR.cf=nCopyCoeff(r1->cf);
}
else /* different type */
{
if (getCoeffType(r1->cf)==n_Zp)
{
if (getCoeffType(r2->cf)==n_Q)
{
tmpR.cf=nCopyCoeff(r1->cf);
}
else if (nCoeff_is_Extension(r2->cf) && rChar(r2) == rChar(r1))
{
/*AlgExtInfo extParam;
extParam.r = r2->cf->extRing;
extParam.i = r2->cf->extRing->qideal;*/
tmpR.cf=nCopyCoeff(r2->cf);
}
else
{
WerrorS("Z/p+...");
return -1;
}
}
else if ((getCoeffType(r1->cf)==n_Zn)||(getCoeffType(r1->cf)==n_Znm))
{
if (getCoeffType(r2->cf)==n_Q)
{
tmpR.cf=nCopyCoeff(r1->cf);
}
else if (nCoeff_is_Extension(r2->cf)
&& (mpz_cmp(r1->cf->modNumber,r2->cf->extRing->cf->modNumber)==0))
{ // covers transext.cc and algext.cc
tmpR.cf=nCopyCoeff(r2->cf);
}
else
{
WerrorS("Z/n+...");
return -1;
}
}
else if (getCoeffType(r1->cf)==n_R)
{
WerrorS("R+..");
return -1;
}
else if (getCoeffType(r1->cf)==n_Q)
{
if (getCoeffType(r2->cf)==n_Zp)
{
tmpR.cf=nCopyCoeff(r2->cf);
}
else if (nCoeff_is_Extension(r2->cf))
{
tmpR.cf=nCopyCoeff(r2->cf);
}
else
{
WerrorS("Q+...");
return -1;
}
}
else if (nCoeff_is_Extension(r1->cf))
{
if (r1->cf->extRing->cf==r2->cf)
{
tmpR.cf=nCopyCoeff(r1->cf);
}
else if (getCoeffType(r1->cf->extRing->cf)==n_Zp && getCoeffType(r2->cf)==n_Q) //r2->cf == n_Zp should have been handled above
{
tmpR.cf=nCopyCoeff(r1->cf);
}
else
{
WerrorS ("coeff sum of two extension fields not implemented");
return -1;
}
}
else
{
WerrorS("coeff sum not yet implemented");
return -1;
}
}
/* variable names ========================================================*/
int i,j,k;
int l=r1->N+r2->N;
char **names=(char **)omAlloc0(l*sizeof(char *));
k=0;
// collect all varnames from r1, except those which are parameters
// of r2, or those which are the empty string
for (i=0;i<r1->N;i++)
{
BOOLEAN b=TRUE;
if (*(r1->names[i]) == '\0')
b = FALSE;
else if ((rParameter(r2)!=NULL) && (strlen(r1->names[i])==1))
{
if (vartest)
{
for(j=0;j<rPar(r2);j++)
{
if (strcmp(r1->names[i],rParameter(r2)[j])==0)
{
b=FALSE;
break;
}
}
}
}
if (b)
{
//Print("name : %d: %s\n",k,r1->names[i]);
names[k]=omStrDup(r1->names[i]);
k++;
}
//else
// Print("no name (par1) %s\n",r1->names[i]);
}
// Add variables from r2, except those which are parameters of r1
// those which are empty strings, and those which equal a var of r1
for(i=0;i<r2->N;i++)
{
BOOLEAN b=TRUE;
if (*(r2->names[i]) == '\0')
b = FALSE;
else if ((rParameter(r1)!=NULL) && (strlen(r2->names[i])==1))
{
if (vartest)
{
for(j=0;j<rPar(r1);j++)
{
if (strcmp(r2->names[i],rParameter(r1)[j])==0)
{
b=FALSE;
break;
}
}
}
}
if (b)
{
if (vartest)
{
for(j=0;j<r1->N;j++)
{
if (strcmp(r1->names[j],r2->names[i])==0)
{
b=FALSE;
break;
}
}
}
if (b)
{
//Print("name : %d : %s\n",k,r2->names[i]);
names[k]=omStrDup(r2->names[i]);
k++;
}
//else
// Print("no name (var): %s\n",r2->names[i]);
}
//else
// Print("no name (par): %s\n",r2->names[i]);
}
// check whether we found any vars at all
if (k == 0)
{
names[k]=omStrDup("");
k=1;
}
tmpR.N=k;
tmpR.names=names;
/* ordering *======================================================== */
tmpR.OrdSgn=0;
if ((dp_dp==2)
&& (r1->OrdSgn==1)
&& (r2->OrdSgn==1)
#ifdef HAVE_PLURAL
&& !rIsPluralRing(r1) && !rIsPluralRing(r2)
#endif
)
{
tmpR.order=(rRingOrder_t*)omAlloc0(4*sizeof(rRingOrder_t));
tmpR.block0=(int*)omAlloc0(4*sizeof(int));
tmpR.block1=(int*)omAlloc0(4*sizeof(int));
tmpR.wvhdl=(int**) omAlloc0(4*sizeof(int**));
// ----
tmpR.block0[0] = 1;
tmpR.block1[0] = rVar(r1)+rVar(r2);
tmpR.order[0] = ringorder_aa;
tmpR.wvhdl[0]=(int*)omAlloc0((rVar(r1)+rVar(r2) + 1)*sizeof(int));
for(int i=0;i<rVar(r1);i++) tmpR.wvhdl[0][i]=1;
// ----
tmpR.block0[1] = 1;
tmpR.block1[1] = rVar(r1)+rVar(r2);
tmpR.order[1] = ringorder_dp;
// ----
tmpR.order[2] = ringorder_C;
}
else if (dp_dp
#ifdef HAVE_PLURAL
&& !rIsPluralRing(r1) && !rIsPluralRing(r2)
#endif
)
{
tmpR.order=(rRingOrder_t*)omAlloc(4*sizeof(rRingOrder_t));
tmpR.block0=(int*)omAlloc0(4*sizeof(int));
tmpR.block1=(int*)omAlloc0(4*sizeof(int));
tmpR.wvhdl=(int**)omAlloc0(4*sizeof(int *));
tmpR.order[0]=ringorder_dp;
tmpR.block0[0]=1;
tmpR.block1[0]=rVar(r1);
if (r2->OrdSgn==1)
{
if ((r2->block0[0]==1)
&& (r2->block1[0]==rVar(r2))
&& ((r2->order[0]==ringorder_wp)
|| (r2->order[0]==ringorder_Wp)
|| (r2->order[0]==ringorder_Dp))
)
{
tmpR.order[1]=r2->order[0];
if (r2->wvhdl[0]!=NULL)
#ifdef HAVE_OMALLOC
tmpR.wvhdl[1]=(int *)omMemDup(r2->wvhdl[0]);
#else
{
int l=r2->block1[0]-r2->block0[0]+1;
if (r2->order[0]==ringorder_a64) l*=2;
else if (r2->order[0]==ringorder_M) l=l*l;
else if (r2->order[0]==ringorder_am)
{
l+=r2->wvhdl[1][r2->block1[0]-r2->block0[0]+1]+1;
}
tmpR.wvhdl[1]=(int*)omalloc(l*sizeof(int));
memcpy(tmpR.wvhdl[1],r2->wvhdl[0],l*sizeof(int));
}
#endif
}
else
tmpR.order[1]=ringorder_dp;
}
else
{
tmpR.order[1]=ringorder_ds;
tmpR.OrdSgn=-1;
}
tmpR.block0[1]=rVar(r1)+1;
tmpR.block1[1]=rVar(r1)+rVar(r2);
tmpR.order[2]=ringorder_C;
tmpR.order[3]=(rRingOrder_t)0;
}
else
{
if ((r1->order[0]==ringorder_unspec)
&& (r2->order[0]==ringorder_unspec))
{
tmpR.order=(rRingOrder_t*)omAlloc(3*sizeof(rRingOrder_t));
tmpR.block0=(int*)omAlloc(3*sizeof(int));
tmpR.block1=(int*)omAlloc(3*sizeof(int));
tmpR.wvhdl=(int**)omAlloc0(3*sizeof(int *));
tmpR.order[0]=ringorder_unspec;
tmpR.order[1]=ringorder_C;
tmpR.order[2]=(rRingOrder_t)0;
tmpR.block0[0]=1;
tmpR.block1[0]=tmpR.N;
}
else if (l==k) /* r3=r1+r2 */
{
int b;
ring rb;
if (r1->order[0]==ringorder_unspec)
{
/* extend order of r2 to r3 */
b=rBlocks(r2);
rb=r2;
tmpR.OrdSgn=r2->OrdSgn;
}
else if (r2->order[0]==ringorder_unspec)
{
/* extend order of r1 to r3 */
b=rBlocks(r1);
rb=r1;
tmpR.OrdSgn=r1->OrdSgn;
}
else
{
b=rBlocks(r1)+rBlocks(r2)-2; /* for only one order C, only one 0 */
rb=NULL;
}
tmpR.order=(rRingOrder_t*)omAlloc0(b*sizeof(rRingOrder_t));
tmpR.block0=(int*)omAlloc0(b*sizeof(int));
tmpR.block1=(int*)omAlloc0(b*sizeof(int));
tmpR.wvhdl=(int**)omAlloc0(b*sizeof(int *));
/* weights not implemented yet ...*/
if (rb!=NULL)
{
for (i=0;i<b;i++)
{
tmpR.order[i]=rb->order[i];
tmpR.block0[i]=rb->block0[i];
tmpR.block1[i]=rb->block1[i];
if (rb->wvhdl[i]!=NULL)
WarnS("rSum: weights not implemented");
}
tmpR.block0[0]=1;
}
else /* ring sum for complete rings */
{
for (i=0;r1->order[i]!=0;i++)
{
tmpR.order[i]=r1->order[i];
tmpR.block0[i]=r1->block0[i];
tmpR.block1[i]=r1->block1[i];
if (r1->wvhdl[i]!=NULL)
#ifdef HAVE_OMALLOC
tmpR.wvhdl[i] = (int*) omMemDup(r1->wvhdl[i]);
#else
{
int l=r1->block1[i]-r1->block0[i]+1;
if (r1->order[i]==ringorder_a64) l*=2;
else if (r1->order[i]==ringorder_M) l=l*l;
else if (r1->order[i]==ringorder_am)
{
l+=r1->wvhdl[i][r1->block1[i]-r1->block0[i]+1]+1;
}
tmpR.wvhdl[i]=(int*)omalloc(l*sizeof(int));
memcpy(tmpR.wvhdl[i],r1->wvhdl[i],l*sizeof(int));
}
#endif
}
j=i;
i--;
if ((r1->order[i]==ringorder_c)
||(r1->order[i]==ringorder_C))
{
j--;
tmpR.order[b-2]=r1->order[i];
}
for (i=0;r2->order[i]!=0;i++)
{
if ((r2->order[i]!=ringorder_c)
&&(r2->order[i]!=ringorder_C))
{
tmpR.order[j]=r2->order[i];
tmpR.block0[j]=r2->block0[i]+rVar(r1);
tmpR.block1[j]=r2->block1[i]+rVar(r1);
if (r2->wvhdl[i]!=NULL)
{
#ifdef HAVE_OMALLOC
tmpR.wvhdl[j] = (int*) omMemDup(r2->wvhdl[i]);
#else
{
int l=r2->block1[i]-r2->block0[i]+1;
if (r2->order[i]==ringorder_a64) l*=2;
else if (r2->order[i]==ringorder_M) l=l*l;
else if (r2->order[i]==ringorder_am)
{
l+=r2->wvhdl[i][r2->block1[i]-r2->block0[i]+1]+1;
}
tmpR.wvhdl[j]=(int*)omalloc(l*sizeof(int));
memcpy(tmpR.wvhdl[j],r2->wvhdl[i],l*sizeof(int));
}
#endif
}
j++;
}
}
if((r1->OrdSgn==-1)||(r2->OrdSgn==-1))
tmpR.OrdSgn=-1;
}
}
else if ((k==rVar(r1)) && (k==rVar(r2))) /* r1 and r2 are "quite"
the same ring */
/* copy r1, because we have the variables from r1 */
{
int b=rBlocks(r1);
tmpR.order=(rRingOrder_t*)omAlloc0(b*sizeof(rRingOrder_t));
tmpR.block0=(int*)omAlloc0(b*sizeof(int));
tmpR.block1=(int*)omAlloc0(b*sizeof(int));
tmpR.wvhdl=(int**)omAlloc0(b*sizeof(int *));
/* weights not implemented yet ...*/
for (i=0;i<b;i++)
{
tmpR.order[i]=r1->order[i];
tmpR.block0[i]=r1->block0[i];
tmpR.block1[i]=r1->block1[i];
if (r1->wvhdl[i]!=NULL)
{
#ifdef HAVE_OMALLOC
tmpR.wvhdl[i] = (int*) omMemDup(r1->wvhdl[i]);
#else
{
int l=r1->block1[i]-r1->block0[i]+1;
if (r1->order[i]==ringorder_a64) l*=2;
else if (r1->order[i]==ringorder_M) l=l*l;
else if (r1->order[i]==ringorder_am)
{
l+=r1->wvhdl[i][r1->block1[i]-r1->block0[i]+1]+1;
}
tmpR.wvhdl[i]=(int*)omalloc(l*sizeof(int));
memcpy(tmpR.wvhdl[i],r1->wvhdl[i],l*sizeof(int));
}
#endif
}
}
tmpR.OrdSgn=r1->OrdSgn;
}
else
{
for(i=0;i<k;i++) omFree((ADDRESS)tmpR.names[i]);
omFreeSize((ADDRESS)names,tmpR.N*sizeof(char *));
Werror("variables must not overlap (# of vars: %d,%d -> %d)",rVar(r1),rVar(r2),k);
return -1;
}
}
tmpR.bitmask=si_max(r1->bitmask,r2->bitmask);
sum=(ring)omAllocBin(sip_sring_bin);
memcpy(sum,&tmpR,sizeof(ip_sring));
rComplete(sum);
//#ifdef RDEBUG
// rDebugPrint(sum);
//#endif
#ifdef HAVE_PLURAL
if(1)
{
// ring old_ring = currRing;
BOOLEAN R1_is_nc = rIsPluralRing(r1);
BOOLEAN R2_is_nc = rIsPluralRing(r2);
if ( (R1_is_nc) || (R2_is_nc))
{
ring R1 = nc_rCreateNCcomm_rCopy(r1);
assume( rIsPluralRing(R1) );
#if 0
#ifdef RDEBUG
rWrite(R1);
rDebugPrint(R1);
#endif
#endif
ring R2 = nc_rCreateNCcomm_rCopy(r2);
#if 0
#ifdef RDEBUG
rWrite(R2);
rDebugPrint(R2);
#endif
#endif
// rChangeCurrRing(sum); // ?
// Projections from R_i into Sum:
/* multiplication matrices business: */
/* find permutations of vars and pars */
int *perm1 = (int *)omAlloc0((rVar(R1)+1)*sizeof(int));
int *par_perm1 = NULL;
if (rPar(R1)!=0) par_perm1=(int *)omAlloc0((rPar(R1)+1)*sizeof(int));
int *perm2 = (int *)omAlloc0((rVar(R2)+1)*sizeof(int));
int *par_perm2 = NULL;
if (rPar(R2)!=0) par_perm2=(int *)omAlloc0((rPar(R2)+1)*sizeof(int));
maFindPerm(R1->names, rVar(R1), rParameter(R1), rPar(R1),
sum->names, rVar(sum), rParameter(sum), rPar(sum),
perm1, par_perm1, sum->cf->type);
maFindPerm(R2->names, rVar(R2), rParameter(R2), rPar(R2),
sum->names, rVar(sum), rParameter(sum), rPar(sum),
perm2, par_perm2, sum->cf->type);
matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
// !!!! BUG? C1 and C2 might live in different baserings!!!
int l = rVar(R1) + rVar(R2);
matrix C = mpNew(l,l);
matrix D = mpNew(l,l);
for (i = 1; i <= rVar(R1); i++)
for (j= rVar(R1)+1; j <= l; j++)
MATELEM(C,i,j) = p_One(sum); // in 'sum'
id_Test((ideal)C, sum);
nMapFunc nMap1 = n_SetMap(R1->cf,sum->cf); /* can change something global: not usable
after the next nSetMap call :( */
// Create blocked C and D matrices:
for (i=1; i<= rVar(R1); i++)
for (j=i+1; j<=rVar(R1); j++)
{
assume(MATELEM(C1,i,j) != NULL);
MATELEM(C,i,j) = p_PermPoly(MATELEM(C1,i,j), perm1, R1, sum, nMap1, par_perm1, rPar(R1)); // need ADD + CMP ops.
if (MATELEM(D1,i,j) != NULL)
MATELEM(D,i,j) = p_PermPoly(MATELEM(D1,i,j), perm1, R1, sum, nMap1, par_perm1, rPar(R1));
}
id_Test((ideal)C, sum);
id_Test((ideal)D, sum);
nMapFunc nMap2 = n_SetMap(R2->cf,sum->cf); /* can change something global: not usable
after the next nSetMap call :( */
for (i=1; i<= rVar(R2); i++)
for (j=i+1; j<=rVar(R2); j++)
{
assume(MATELEM(C2,i,j) != NULL);
MATELEM(C,rVar(R1)+i,rVar(R1)+j) = p_PermPoly(MATELEM(C2,i,j),perm2,R2,sum, nMap2,par_perm2,rPar(R2));
if (MATELEM(D2,i,j) != NULL)
MATELEM(D,rVar(R1)+i,rVar(R1)+j) = p_PermPoly(MATELEM(D2,i,j),perm2,R2,sum, nMap2,par_perm2,rPar(R2));
}
id_Test((ideal)C, sum);
id_Test((ideal)D, sum);
// Now sum is non-commutative with blocked structure constants!
if (nc_CallPlural(C, D, NULL, NULL, sum, false, false, true, sum))
WarnS("Error initializing non-commutative multiplication!");
/* delete R1, R2*/
#if 0
#ifdef RDEBUG
rWrite(sum);
rDebugPrint(sum);
Print("\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
#endif
#endif
rDelete(R1);
rDelete(R2);
/* delete perm arrays */
if (perm1!=NULL) omFree((ADDRESS)perm1);
if (perm2!=NULL) omFree((ADDRESS)perm2);
if (par_perm1!=NULL) omFree((ADDRESS)par_perm1);
if (par_perm2!=NULL) omFree((ADDRESS)par_perm2);
// rChangeCurrRing(old_ring);
}
}
#endif
ideal Q=NULL;
ideal Q1=NULL, Q2=NULL;
if (r1->qideal!=NULL)
{
// rChangeCurrRing(sum);
// if (r2->qideal!=NULL)
// {
// WerrorS("todo: qring+qring");
// return -1;
// }
// else
// {}
/* these were defined in the Plural Part above... */
int *perm1 = (int *)omAlloc0((rVar(r1)+1)*sizeof(int));
int *par_perm1 = NULL;
if (rPar(r1)!=0) par_perm1=(int *)omAlloc0((rPar(r1)+1)*sizeof(int));
maFindPerm(r1->names, rVar(r1), rParameter(r1), rPar(r1),
sum->names, rVar(sum), rParameter(sum), rPar(sum),
perm1, par_perm1, sum->cf->type);
nMapFunc nMap1 = n_SetMap(r1->cf,sum->cf);
Q1 = idInit(IDELEMS(r1->qideal),1);
for (int for_i=0;for_i<IDELEMS(r1->qideal);for_i++)
Q1->m[for_i] = p_PermPoly(
r1->qideal->m[for_i], perm1,
r1, sum,
nMap1,
par_perm1, rPar(r1));
omFree((ADDRESS)perm1);
}
if (r2->qideal!=NULL)
{
//if (currRing!=sum)
// rChangeCurrRing(sum);
int *perm2 = (int *)omAlloc0((rVar(r2)+1)*sizeof(int));
int *par_perm2 = NULL;
if (rPar(r2)!=0) par_perm2=(int *)omAlloc0((rPar(r2)+1)*sizeof(int));
maFindPerm(r2->names, rVar(r2), rParameter(r2), rPar(r2),
sum->names, rVar(sum), rParameter(sum), rPar(sum),
perm2, par_perm2, sum->cf->type);
nMapFunc nMap2 = n_SetMap(r2->cf,sum->cf);
Q2 = idInit(IDELEMS(r2->qideal),1);
for (int for_i=0;for_i<IDELEMS(r2->qideal);for_i++)
Q2->m[for_i] = p_PermPoly(
r2->qideal->m[for_i], perm2,
r2, sum,
nMap2,
par_perm2, rPar(r2));
omFree((ADDRESS)perm2);
}
if (Q1!=NULL)
{
if ( Q2!=NULL)
Q = id_SimpleAdd(Q1,Q2,sum);
else
Q=id_Copy(Q1,sum);
}
else
{
if ( Q2!=NULL)
Q = id_Copy(Q2,sum);
else
Q=NULL;
}
sum->qideal = Q;
#ifdef HAVE_PLURAL
if( rIsPluralRing(sum) )
nc_SetupQuotient( sum );
#endif
return 1;
}
si_max
static int si_max(const int a, const int b)
Definition auxiliary.h:125
n_R
@ n_R
single prescision (6,6) real numbers
Definition coeffs.h:31
n_Znm
@ n_Znm
only used if HAVE_RINGS is defined
Definition coeffs.h:45
n_Zn
@ n_Zn
only used if HAVE_RINGS is defined
Definition coeffs.h:44
maFindPerm
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:155
rChar
int rChar(ring r)
Definition ring.cc:719
nc_rCreateNCcomm_rCopy
ring nc_rCreateNCcomm_rCopy(ring r)
Definition ring.cc:725
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition simpleideals.cc:35
id_SimpleAdd
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
Definition simpleideals.cc:790
Q
#define Q
Definition sirandom.c:26
ip_sring
Definition ring.h:254
ip_sring::cf
n_Procs_s * cf
Definition ring.h:374
ip_sring::block0
int * block0
Definition ring.h:260
ip_sring::N
short N
Definition ring.h:309
ip_sring::block1
int * block1
Definition ring.h:261
ip_sring::order
rRingOrder_t * order
Definition ring.h:259
ip_sring::wvhdl
int ** wvhdl
Definition ring.h:263
ip_sring::bitmask
unsigned long bitmask
Definition ring.h:356
ip_sring::names
char ** names
Definition ring.h:264
ip_sring::OrdSgn
short OrdSgn
Definition ring.h:311

## rTypeOfMatrixOrder()

int rTypeOfMatrixOrder | ( | const intvec * | order | ) |

Definition at line 186 of file ring.cc.

{
int i=0,j,typ=1;
int sz = (int)sqrt((double)(order->length()-2));
if ((sz*sz)!=(order->length()-2))
{
WerrorS("Matrix order is not a square matrix");
typ=0;
}
while ((i<sz) && (typ==1))
{
j=0;
while ((j<sz) && ((*order)[j*sz+i+2]==0)) j++;
if (j>=sz)
{
typ = 0;
WerrorS("Matrix order not complete");
}
else if ((*order)[j*sz+i+2]<0)
typ = -1;
else
i++;
}
return typ;
}
sqrt
gmp_float sqrt(const gmp_float &a)
Definition mpr_complex.cc:319

## rUnComplete()

void rUnComplete | ( | ring | r | ) |

Definition at line 4057 of file ring.cc.

{
if (r == NULL) return;
if (r->VarOffset != NULL)
{
if (r->OrdSize!=0 && r->typ != NULL)
{
for(int i = 0; i < r->OrdSize; i++)
if( r->typ[i].ord_typ == ro_is) // Search for suffixes! (prefix have the same VarOffset)
{
id_Delete(&r->typ[i].data.is.F, r);
if( r->typ[i].data.is.pVarOffset != NULL )
{
omFreeSize((ADDRESS)r->typ[i].data.is.pVarOffset, (r->N +1)*sizeof(int));
}
}
else if (r->typ[i].ord_typ == ro_syz)
{
if(r->typ[i].data.syz.limit > 0)
omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*sizeof(int));
}
else if (r->typ[i].ord_typ == ro_syzcomp)
{
assume( r->typ[i].data.syzcomp.ShiftedComponents == NULL );
assume( r->typ[i].data.syzcomp.Components == NULL );
// WarnS( "rUnComplete : ord_typ == ro_syzcomp was unhandled!!! Possibly memory leak!!!" );
#ifndef SING_NDEBUG
// assume(0);
#endif
}
omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord)); r->typ = NULL;
}
if (r->PolyBin != NULL)
omUnGetSpecBin(&(r->PolyBin));
omFreeSize((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
r->VarOffset=NULL;
if (r->ordsgn != NULL && r->CmpL_Size != 0)
{
omFreeSize((ADDRESS)r->ordsgn,r->ExpL_Size*sizeof(long));
r->ordsgn=NULL;
}
if (r->p_Procs != NULL)
{
omFreeSize(r->p_Procs, sizeof(p_Procs_s));
r->p_Procs=NULL;
}
omfreeSize(r->VarL_Offset, r->VarL_Size*sizeof(int));
r->VarL_Offset=NULL;
}
if (r->NegWeightL_Offset!=NULL)
{
omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*sizeof(int));
r->NegWeightL_Offset=NULL;
}
}
omfreeSize
#define omfreeSize(addr, size)
Definition omAllocDecl.h:236
omUnGetSpecBin
#define omUnGetSpecBin(bin_ptr)
Definition omBin.h:14

## rVarStr()

char * rVarStr | ( | ring | r | ) |

Definition at line 628 of file ring.cc.

{
if ((r==NULL)||(r->names==NULL)) return omStrDup("");
int i;
int l=2;
char *s;
for (i=0; i<r->N; i++)
{
l+=strlen(r->names[i])+1;
}
s=(char *)omAlloc((long)l);
s[0]='\0';
for (i=0; i<r->N-1; i++)
{
strcat(s,r->names[i]);
strcat(s,",");
}
strcat(s,r->names[i]);
return s;
}

## rWrite()

void rWrite | ( | ring | r,
|  | BOOLEAN | details )

Definition at line 227 of file ring.cc.

{
if ((r==NULL)||(r->order==NULL))
return; /*to avoid printing after errors....*/
assume(r != NULL);
const coeffs C = r->cf;
assume(C != NULL);
int nblocks=rBlocks(r);
// omCheckAddrSize(r,sizeof(ip_sring));
omCheckAddrSize(r->order,nblocks*sizeof(int));
omCheckAddrSize(r->block0,nblocks*sizeof(int));
omCheckAddrSize(r->block1,nblocks*sizeof(int));
omCheckAddrSize(r->wvhdl,nblocks*sizeof(int *));
omCheckAddrSize(r->names,r->N*sizeof(char *));
nblocks--;
//Print("ref:%d, C->ref:%d\n",r->ref,C->ref);
PrintS("// coefficients: ");
if( nCoeff_is_algExt(C) )
{
// NOTE: the following (non-thread-safe!) UGLINESS
// (changing naRing->ShortOut for a while) is due to Hans!
// Just think of other ring using the VERY SAME naRing and possible
// side-effects...
ring R = C->extRing;
const BOOLEAN bSaveShortOut = rShortOut(R); R->ShortOut = rShortOut(r) & rCanShortOut(R);
n_CoeffWrite(C, details); // for correct printing of minpoly... WHAT AN UGLINESS!!!
R->ShortOut = bSaveShortOut;
}
else
n_CoeffWrite(C, details);
if (C->is_field) PrintS(" considered as a field\n");
else PrintS(" considered as a non-field\n");
// {
// PrintS("// characteristic : ");
//
// char const * const * const params = rParameter(r);
//
// if (params!=NULL)
// {
// Print ("// %d parameter : ",rPar(r));
//
// char const * const * sp= params;
// int nop=0;
// while (nop<rPar(r))
// {
// PrintS(*sp);
// PrintS(" ");
// sp++; nop++;
// }
// PrintS("\n// minpoly : ");
// if ( rField_is_long_C(r) )
// {
// // i^2+1:
// Print("(%s^2+1)\n", params[0]);
// }
// else if (rMinpolyIsNULL(r))
// {
// PrintS("0\n");
// }
// else
// {
// StringSetS(""); n_Write(r->cf->minpoly, r); PrintS(StringEndS("\n")); // NOTE/TODO: use StringAppendS("\n"); omFree(s);
// }
// //if (r->qideal!=NULL)
// //{
// // iiWriteMatrix((matrix)r->qideal,"// minpolys",1,r,0);
// // PrintLn();
// //}
// }
// }
Print("// number of vars : %d",r->N);
//for (nblocks=0; r->order[nblocks]; nblocks++);
nblocks=rBlocks(r)-1;
for (int l=0, nlen=0 ; l<nblocks; l++)
{
int i=0;
Print("\n// block %3d : ",l+1);
Print("ordering %s", rSimpleOrdStr(r->order[l]));
if (r->order[l] == ringorder_IS)
{
assume( r->block0[l] == r->block1[l] );
const int s = r->block0[l];
assume( (-2 < s) && (s < 2) );
Print("(%d)", s); // 0 => prefix! +/-1 => suffix!
continue;
}
else if (r->order[l]==ringorder_s)
{
assume( l == 0 );
Print(" syz_comp: %d",r->block0[l]);
continue;
}
else if (
( (r->order[l] >= ringorder_lp)
||(r->order[l] == ringorder_M)
||(r->order[l] == ringorder_a)
||(r->order[l] == ringorder_am)
||(r->order[l] == ringorder_a64)
||(r->order[l] == ringorder_aa) ) && (r->order[l] < ringorder_IS) )
{
PrintS("\n// : names ");
for (i = r->block0[l]-1; i<r->block1[l]; i++)
{
nlen = strlen(r->names[i]);
Print(" %s",r->names[i]);
}
}
if (r->wvhdl[l]!=NULL)
{
#ifndef SING_NDEBUG
if((r->order[l] != ringorder_wp)
&&(r->order[l] != ringorder_Wp)
&&(r->order[l] != ringorder_ws)
&&(r->order[l] != ringorder_Ws)
&&(r->order[l] != ringorder_a)
&&(r->order[l] != ringorder_a64)
&&(r->order[l] != ringorder_am)
&&(r->order[l] != ringorder_M))
{
Warn("should not have wvhdl entry at pos. %d",l);
}
#endif
int bl=r->block1[l]-r->block0[l]+1;
for (int j= 0;
j<(r->block1[l]-r->block0[l]+1)*(r->block1[l]-r->block0[l]+1);
j+=bl)
{
PrintS("\n// : weights ");
for (i = 0; i<=r->block1[l]-r->block0[l]; i++)
{
if (r->order[l] == ringorder_a64)
{
int64 *w=(int64 *)r->wvhdl[l];
#if SIZEOF_LONG == 4
Print("%*lld " ,nlen,w[i+j]);
#else
Print(" %*ld" ,nlen,w[i+j]);
#endif
}
else
Print(" %*d" ,nlen,r->wvhdl[l][i+j]);
}
if (r->order[l]!=ringorder_M) break;
}
if (r->order[l]==ringorder_am)
{
int m=r->wvhdl[l][bl];
Print("\n// : %d module weights ",m);
m+=bl;i=bl+1;
for(;i<=m;i++) Print(" %*d" ,nlen,r->wvhdl[l][i]);
}
}
}
#ifdef HAVE_PLURAL
if(rIsPluralRing(r))
{
PrintS("\n// noncommutative relations:");
if( details )
{
poly pl=NULL;
int nl;
int i,j;
for (i = 1; i<r->N; i++)
{
for (j = i+1; j<=r->N; j++)
{
nl = n_IsOne(p_GetCoeff(MATELEM(r->GetNC()->C,i,j),r), r->cf);
if ( (MATELEM(r->GetNC()->D,i,j)!=NULL) || (!nl) )
{
Print("\n// %s%s=",r->names[j-1],r->names[i-1]);
pl = MATELEM(r->GetNC()->MT[UPMATELEM(i,j,r->N)],1,1);
p_Write0(pl, r, r);
}
}
}
} else
PrintS(" ...");
#if MYTEST /*Singularg should not differ from Singular except in error case*/
Print("\n// noncommutative type:%d", (int)ncRingType(r));
Print("\n// is skew constant:%d",r->GetNC()->IsSkewConstant);
if( rIsSCA(r) )
{
Print("\n// alternating variables: [%d, %d]", scaFirstAltVar(r), scaLastAltVar(r));
const ideal Q = SCAQuotient(r); // resides within r!
PrintS("\n// quotient of sca by ideal");
if (Q!=NULL)
{
iiWriteMatrix((matrix)Q,"scaQ",1,r,0);
}
else
PrintS(" (NULL)");
}
#endif
}
if (rIsLPRing(r))
{
Print("\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
}
#endif
if (r->qideal!=NULL)
{
PrintS("\n// quotient ring from ideal");
if( details )
{
PrintLn();
iiWriteMatrix((matrix)r->qideal,"_",1,r,0);
} else PrintS(" ...");
}
}
n_CoeffWrite
static FORCE_INLINE void n_CoeffWrite(const coeffs r, BOOLEAN details=TRUE)
output the coeff description
Definition coeffs.h:722
n_IsOne
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:474
UPMATELEM
#define UPMATELEM(i, j, nVar)
Definition nc.h:36
iiWriteMatrix
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
Definition matpol.cc:828
p_Write0
void p_Write0(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:332
rShortOut
static BOOLEAN rShortOut(const ring r)
Definition ring.h:587
rCanShortOut
static BOOLEAN rCanShortOut(const ring r)
Definition ring.h:592
SCAQuotient
ideal SCAQuotient(const ring r)
Definition sca.h:10

## sign()

int sign | ( | int | x | ) |

inline static

Definition at line 3504 of file ring.cc.

{ return (x > 0) - (x < 0);}
x
Variable x
Definition cfModGcd.cc:4090

## Variable Documentation

## char_ptr_bin

VAR omBin char_ptr_bin = omGetSpecBin(sizeof(char_ptr))

Definition at line 44 of file ring.cc.

## pDBsyzComp

VAR int pDBsyzComp =0

Definition at line 5226 of file ring.cc.

## ringorder_name

const char* const ringorder_name[]

static

Initial value:
=
{
" ?",
"a",
"A",
"c",
"C",
"M",
"S",
"s",
"lp",
"dp",
"ip",
"Dp",
"wp",
"Wp",
"Ip",
"ls",
"ds",
"Ds",
"ws",
"Ws",
"am",
"L",
"aa",
"is",
"IS",
" _"
}

Definition at line 47 of file ring.cc.

{
" ?", ///< ringorder_no = 0,
"a", ///< ringorder_a,
"A", ///< ringorder_a64,
"c", ///< ringorder_c,
"C", ///< ringorder_C,
"M", ///< ringorder_M,
"S", ///< ringorder_S,
"s", ///< ringorder_s,
"lp", ///< ringorder_lp,
"dp", ///< ringorder_dp,
"ip", ///< ringorder_ip,
"Dp", ///< ringorder_Dp,
"wp", ///< ringorder_wp,
"Wp", ///< ringorder_Wp,
"Ip", ///< ringorder_Ip,
"ls", ///< ringorder_ls,
"ds", ///< ringorder_ds,
"Ds", ///< ringorder_Ds,
"ws", ///< ringorder_ws,
"Ws", ///< ringorder_Ws,
"am", ///< ringorder_am,
"L", ///< ringorder_L,
"aa", ///< ringorder_aa
"is", ///< ringorder_is,
"IS", ///< ringorder_IS
" _" ///< ringorder_unspec
};

## sip_sring_bin

VAR omBin sip_sring_bin = omGetSpecBin(sizeof(ip_sring))

Definition at line 43 of file ring.cc.