My Project
Macros | Typedefs | Functions | Variables
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)   if(r->pFDeg == A) PrintS( "" #A "" )
 
#define rOppVar(R, I)   (rVar(R)+1-I)
 

Typedefs

typedef char * char_ptr
 

Functions

const char * rSimpleOrdStr (int ord)
 
void rDelete (ring r)
 unconditionally deletes fields in r More...
 
static void rSetVarL (ring r)
 set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex More...
 
static unsigned long rGetDivMask (int bits)
 get r->divmask depending on bits per exponent More...
 
static void rRightAdjustVarOffset (ring r)
 right-adjust r->VarOffset More...
 
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. More...
 
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 More...
 
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 More...
 
BOOLEAN rSamePolyRep (ring r1, ring r2)
 returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analogue to rEqual but not so strict More...
 
rOrderType_t rGetOrderType (ring r)
 
BOOLEAN rHas_c_Ordering (const ring r)
 
BOOLEAN rHasSimpleOrder (const ring r)
 
BOOLEAN rHasSimpleLexOrder (const ring r)
 returns TRUE, if simple lp or ls ordering More...
 
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 More...
 
BOOLEAN rOrd_is_Totaldegree_Ordering (const ring r)
 
BOOLEAN rOrd_is_WeightedDegree_Ordering (const ring r)
 
BOOLEAN rIsPolyVar (int v, const ring r)
 returns TRUE if var(i) belongs to p-block More...
 
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, 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 More...
 
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 *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 More...
 
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 More...
 
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 More...
 
void pISUpdateComponents (ideal F, const intvec *const V, const int MIN, const 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 More...
 
ring rAssure_SyzComp_CompLastBlock (const ring r)
 makes sure that c/C ordering is last ordering and SyzIndex is first More...
 
static ring rAssure_Global (rRingOrder_t b1, rRingOrder_t b2, const ring r)
 
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_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! More...
 
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 allright! More...
 
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 More...
 
BOOLEAN rRing_is_Homog (const ring r)
 
BOOLEAN rRing_has_CompLastBlock (const ring r)
 
BOOLEAN rRing_ord_pure_dp (const ring r)
 
BOOLEAN rRing_ord_pure_Dp (const ring r)
 
BOOLEAN rRing_ord_pure_lp (const ring r)
 
int64rGetWeightVec (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)
 
void rModify_a_to_A (ring r)
 
poly rGetVar (const int varIndex, const ring r)
 
int n_IsParam (const number m, const ring r)
 TODO: rewrite somehow... More...
 
ring rPlusVar (const ring r, char *v, int left)
 K[x],"y" -> K[x,y] resp. K[y,x]. More...
 
ring rMinusVar (const ring r, char *v)
 undo rPlusVar More...
 

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

◆ pFDeg_CASE

#define pFDeg_CASE (   A)    if(r->pFDeg == A) PrintS( "" #A "" )

◆ rOppVar

#define rOppVar (   R,
 
)    (rVar(R)+1-I)

Definition at line 5247 of file ring.cc.

Typedef Documentation

◆ char_ptr

typedef char* char_ptr

Definition at line 42 of file ring.cc.

Function Documentation

◆ m_DebugPrint()

static void m_DebugPrint ( const poly  p,
const ring  R 
)
inlinestatic

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

Definition at line 4300 of file ring.cc.

4301 {
4302  Print("\nexp[0..%d]\n", R->ExpL_Size - 1);
4303  for(int i = 0; i < R->ExpL_Size; i++)
4304  Print("%09lx ", p->exp[i]);
4305  PrintLn();
4306  Print("v0:%9ld ", p_GetComp(p, R));
4307  for(int i = 1; i <= R->N; i++) Print(" v%d:%5ld",i, p_GetExp(p, i, R));
4308  PrintLn();
4309 }
int i
Definition: cfEzgcd.cc:132
int p
Definition: cfModGcd.cc:4080
#define Print
Definition: emacs.cc:80
#define p_GetComp(p, r)
Definition: monomials.h:64
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:469
void PrintLn()
Definition: reporter.cc:310
#define R
Definition: sirandom.c:27

◆ n_IsParam()

int n_IsParam ( const number  m,
const ring  r 
)

TODO: rewrite somehow...

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

Definition at line 5765 of file ring.cc.

5766 {
5767  assume(r != NULL);
5768  const coeffs C = r->cf;
5769  assume(C != NULL);
5770 
5772 
5773  const n_coeffType _filed_type = getCoeffType(C);
5774 
5775  if(( _filed_type == n_algExt )||( _filed_type == n_polyExt ))
5776  return naIsParam(m, C);
5777 
5778  if( _filed_type == n_transExt )
5779  return ntIsParam(m, C);
5780 
5781  Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C));
5782 
5783  return 0;
5784 }
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition: algext.cc:1091
int m
Definition: cfEzgcd.cc:128
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:870
n_coeffType
Definition: coeffs.h:28
@ n_polyExt
used to represent polys as coeffcients
Definition: coeffs.h:35
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition: coeffs.h:36
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:39
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define assume(x)
Definition: mod2.h:387
The main handler for Singular numbers which are suitable for Singular polynomials.
#define NULL
Definition: omList.c:12
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition: transext.cc:2216

◆ nc_rComplete()

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

Definition at line 5654 of file ring.cc.

5659 {
5660 // NOTE: Originally used only by idElimination to transfer NC structure to dest
5661 // ring created by dirty hack (without nc_CallPlural)
5662  rTest(src);
5663 
5664  assume(!rIsPluralRing(dest)); // destination must be a newly constructed commutative ring
5665 
5666  if (!rIsPluralRing(src))
5667  {
5668  return FALSE;
5669  }
5670 
5671  const int N = dest->N;
5672 
5673  assume(src->N == N);
5674 
5675 // ring save = currRing;
5676 
5677 // if (dest != save)
5678 // rChangeCurrRing(dest);
5679 
5680  const ring srcBase = src;
5681 
5682  assume( n_SetMap(srcBase->cf,dest->cf) == n_SetMap(dest->cf,dest->cf) ); // currRing is important here!
5683 
5684  matrix C = mpNew(N,N); // ring independent
5685  matrix D = mpNew(N,N);
5686 
5687  matrix C0 = src->GetNC()->C;
5688  matrix D0 = src->GetNC()->D;
5689 
5690  // map C and D into dest
5691  for (int i = 1; i < N; i++)
5692  {
5693  for (int j = i + 1; j <= N; j++)
5694  {
5695  const number n = n_Copy(p_GetCoeff(MATELEM(C0,i,j), srcBase), srcBase->cf); // src, mapping for coeffs into currRing = dest!
5696  const poly p = p_NSet(n, dest);
5697  MATELEM(C,i,j) = p;
5698  if (MATELEM(D0,i,j) != NULL)
5699  MATELEM(D,i,j) = prCopyR(MATELEM(D0,i,j), srcBase, dest); // ?
5700  }
5701  }
5702  /* One must test C and D _only_ in r->GetNC()->basering!!! not in r!!! */
5703 
5704  id_Test((ideal)C, dest);
5705  id_Test((ideal)D, dest);
5706 
5707  if (nc_CallPlural(C, D, NULL, NULL, dest, bSetupQuotient, false, true, dest)) // also takes care about quotient ideal
5708  {
5709  //WarnS("Error transferring non-commutative structure");
5710  // error message should be in the interpreter interface
5711 
5712  mp_Delete(&C, dest);
5713  mp_Delete(&D, dest);
5714 
5715 // if (currRing != save)
5716 // rChangeCurrRing(save);
5717 
5718  return TRUE;
5719  }
5720 
5721 // mp_Delete(&C, dest); // used by nc_CallPlural!
5722 // mp_Delete(&D, dest);
5723 
5724 // if (dest != save)
5725 // rChangeCurrRing(save);
5726 
5727  assume(rIsPluralRing(dest));
5728  return FALSE;
5729 }
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:452
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:723
int j
Definition: facHensel.cc:110
#define D(A)
Definition: gentable.cc:131
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:2682
void mp_Delete(matrix *a, const ring r)
Definition: matpol.cc:880
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
#define p_GetCoeff(p, r)
Definition: monomials.h:50
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1460
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:34
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
#define rTest(r)
Definition: ring.h:787
#define id_Test(A, lR)
Definition: simpleideals.h:78

◆ nc_rCreateNCcomm_rCopy()

ring nc_rCreateNCcomm_rCopy ( ring  r)

Definition at line 717 of file ring.cc.

718 {
719  r = rCopy(r);
720  if (rIsPluralRing(r))
721  return r;
722 
723  matrix C = mpNew(r->N,r->N); // ring-independent!?!
724  matrix D = mpNew(r->N,r->N);
725 
726  for(int i=1; i<r->N; i++)
727  for(int j=i+1; j<=r->N; j++)
728  MATELEM(C,i,j) = p_One( r);
729 
730  if (nc_CallPlural(C, D, NULL, NULL, r, false, true, false, r/*??currRing??*/, TRUE)) // TODO: what about quotient ideal?
731  WarnS("Error initializing multiplication!"); // No reaction!???
732 
733  return r;
734 }
#define WarnS
Definition: emacs.cc:78
poly p_One(const ring r)
Definition: p_polys.cc:1308
ring rCopy(ring r)
Definition: ring.cc:1645

◆ p_DebugPrint()

void p_DebugPrint ( poly  p,
const ring  r 
)

Definition at line 4277 of file ring.cc.

4278 {
4279  int i,j;
4280  p_Write(p,r);
4281  j=2;
4282  while(p!=NULL)
4283  {
4284  Print("\nexp[0..%d]\n",r->ExpL_Size-1);
4285  for(i=0;i<r->ExpL_Size;i++)
4286  Print("%ld ",p->exp[i]);
4287  PrintLn();
4288  Print("v0:%ld ",p_GetComp(p, r));
4289  for(i=1;i<=r->N;i++) Print(" v%d:%ld",i,p_GetExp(p,i, r));
4290  PrintLn();
4291  pIter(p);
4292  j--;
4293  if (j==0) { PrintS("...\n"); break; }
4294  }
4295 }
#define pIter(p)
Definition: monomials.h:37
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:342
void PrintS(const char *s)
Definition: reporter.cc:284

◆ p_SetGlobals()

void p_SetGlobals ( const ring  r,
BOOLEAN  complete 
)

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

Definition at line 3365 of file ring.cc.

3366 {
3367 // // // if (r->ppNoether!=NULL) p_Delete(&r->ppNoether,r); // ???
3368 
3369  r->pLexOrder=r->LexOrder;
3370  if (complete)
3371  {
3373  si_opt_1 |= r->options;
3374  }
3375 }
VAR unsigned si_opt_1
Definition: options.c:5
#define TEST_RINGDEP_OPTS
Definition: options.h:100

◆ pISUpdateComponents()

void pISUpdateComponents ( ideal  F,
const intvec *const  V,
const int  MIN,
const ring  r 
)

Definition at line 4314 of file ring.cc.

4315 {
4316  assume( V != NULL );
4317  assume( MIN >= 0 );
4318 
4319  if( F == NULL )
4320  return;
4321 
4322  for( int j = (F->ncols*F->nrows) - 1; j >= 0; j-- )
4323  {
4324 #ifdef PDEBUG
4325  Print("F[%d]:", j);
4326  p_wrp(F->m[j], r);
4327 #endif
4328 
4329  for( poly p = F->m[j]; p != NULL; pIter(p) )
4330  {
4331  int c = p_GetComp(p, r);
4332 
4333  if( c > MIN )
4334  {
4335 #ifdef PDEBUG
4336  Print("gen[%d] -> gen(%d)\n", c, MIN + (*V)[ c - MIN - 1 ]);
4337 #endif
4338 
4339  p_SetComp( p, MIN + (*V)[ c - MIN - 1 ], r );
4340  }
4341  }
4342 #ifdef PDEBUG
4343  Print("new F[%d]:", j);
4344  p_Test(F->m[j], r);
4345  p_wrp(F->m[j], r);
4346 #endif
4347  }
4348 }
#define MIN(a, b)
Definition: omDebug.c:102
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:247
#define p_Test(p, r)
Definition: p_polys.h:162
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:373

◆ r_IsRingVar()

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

Definition at line 212 of file ring.cc.

213 {
214  if (names!=NULL)
215  {
216  for (int i=0; i<N; i++)
217  {
218  if (names[i]==NULL) return -1;
219  if (strcmp(n,names[i]) == 0) return (int)i;
220  }
221  }
222  return -1;
223 }

◆ rAssure_C_dp()

ring rAssure_C_dp ( const ring  r)

Definition at line 4932 of file ring.cc.

4933 {
4935 }
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
Definition: ring.cc:4765
@ ringorder_C
Definition: ring.h:73
@ ringorder_dp
Definition: ring.h:78

◆ rAssure_c_dp()

ring rAssure_c_dp ( const ring  r)

Definition at line 4937 of file ring.cc.

4938 {
4940 }
@ ringorder_c
Definition: ring.h:72

◆ rAssure_CompLastBlock()

ring rAssure_CompLastBlock ( ring  r,
BOOLEAN  complete 
)

makes sure that c/C ordering is last ordering

Definition at line 4655 of file ring.cc.

4656 {
4657  int last_block = rBlocks(r) - 2;
4658  if (r->order[last_block] != ringorder_c &&
4659  r->order[last_block] != ringorder_C)
4660  {
4661  int c_pos = 0;
4662  int i;
4663 
4664  for (i=0; i< last_block; i++)
4665  {
4666  if (r->order[i] == ringorder_c || r->order[i] == ringorder_C)
4667  {
4668  c_pos = i;
4669  break;
4670  }
4671  }
4672  if (c_pos != -1)
4673  {
4674  ring new_r = rCopy0(r, FALSE, TRUE);
4675  for (i=c_pos+1; i<=last_block; i++)
4676  {
4677  new_r->order[i-1] = new_r->order[i];
4678  new_r->block0[i-1] = new_r->block0[i];
4679  new_r->block1[i-1] = new_r->block1[i];
4680  new_r->wvhdl[i-1] = new_r->wvhdl[i];
4681  }
4682  new_r->order[last_block] = r->order[c_pos];
4683  new_r->block0[last_block] = r->block0[c_pos];
4684  new_r->block1[last_block] = r->block1[c_pos];
4685  new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4686  if (complete)
4687  {
4688  rComplete(new_r, 1);
4689 
4690 #ifdef HAVE_PLURAL
4691  if (rIsPluralRing(r))
4692  {
4693  if ( nc_rComplete(r, new_r, false) ) // no qideal!
4694  {
4695 #ifndef SING_NDEBUG
4696  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4697 #endif
4698  }
4699  }
4700  assume(rIsPluralRing(r) == rIsPluralRing(new_r));
4701 #endif
4702  }
4703  return new_r;
4704  }
4705  }
4706  return r;
4707 }
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:3400
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition: ring.cc:5654
ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
Definition: ring.cc:1363
static int rBlocks(ring r)
Definition: ring.h:570

◆ rAssure_dp_C()

ring rAssure_dp_C ( const ring  r)

Definition at line 4927 of file ring.cc.

4928 {
4930 }

◆ rAssure_dp_S()

ring rAssure_dp_S ( const ring  r)

Definition at line 4922 of file ring.cc.

4923 {
4925 }
@ ringorder_S
S?
Definition: ring.h:75

◆ rAssure_Global()

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

Definition at line 4765 of file ring.cc.

4766 {
4767  int r_blocks = rBlocks(r);
4768 
4769  assume(b1 == ringorder_c || b1 == ringorder_C ||
4770  b2 == ringorder_c || b2 == ringorder_C ||
4771  b2 == ringorder_S);
4772  if ((r_blocks == 3) &&
4773  (r->order[0] == b1) &&
4774  (r->order[1] == b2) &&
4775  (r->order[2] == 0))
4776  return r;
4777  ring res = rCopy0(r, FALSE, FALSE);
4778  res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
4779  res->block0 = (int*)omAlloc0(3*sizeof(int));
4780  res->block1 = (int*)omAlloc0(3*sizeof(int));
4781  res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
4782  res->order[0] = b1;
4783  res->order[1] = b2;
4784  if (b1 == ringorder_c || b1 == ringorder_C)
4785  {
4786  res->block0[1] = 1;
4787  res->block1[1] = r->N;
4788  }
4789  else
4790  {
4791  res->block0[0] = 1;
4792  res->block1[0] = r->N;
4793  }
4794  rComplete(res, 1);
4795  if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4796 #ifdef HAVE_PLURAL
4797  if (rIsPluralRing(r))
4798  {
4799  if ( nc_rComplete(r, res, false) ) // no qideal!
4800  {
4801 #ifndef SING_NDEBUG
4802  WarnS("error in nc_rComplete");
4803 #endif
4804  }
4805  }
4806 #endif
4807 // rChangeCurrRing(res);
4808  return res;
4809 }
CanonicalForm res
Definition: facAbsFact.cc:60
#define omAlloc0(size)
Definition: omAllocDecl.h:211
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:204
rRingOrder_t
order stuff
Definition: ring.h:68

◆ rAssure_HasComp()

ring rAssure_HasComp ( const ring  r)

Definition at line 4600 of file ring.cc.

4601 {
4602  int last_block;
4603  int i=0;
4604  do
4605  {
4606  if (r->order[i] == ringorder_c ||
4607  r->order[i] == ringorder_C) return r;
4608  if (r->order[i] == 0)
4609  break;
4610  i++;
4611  } while (1);
4612  //WarnS("re-creating ring with comps");
4613  last_block=i-1;
4614 
4615  ring new_r = rCopy0(r, FALSE, FALSE);
4616  i+=2;
4617  new_r->wvhdl=(int **)omAlloc0(i * sizeof(int *));
4618  new_r->order = (rRingOrder_t *) omAlloc0(i * sizeof(rRingOrder_t));
4619  new_r->block0 = (int *) omAlloc0(i * sizeof(int));
4620  new_r->block1 = (int *) omAlloc0(i * sizeof(int));
4621  memcpy(new_r->order,r->order,(i-1) * sizeof(rRingOrder_t));
4622  memcpy(new_r->block0,r->block0,(i-1) * sizeof(int));
4623  memcpy(new_r->block1,r->block1,(i-1) * sizeof(int));
4624  for (int j=0; j<=last_block; j++)
4625  {
4626  if (r->wvhdl[j]!=NULL)
4627  {
4628  new_r->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
4629  }
4630  }
4631  last_block++;
4632  new_r->order[last_block]=ringorder_C;
4633  //new_r->block0[last_block]=0;
4634  //new_r->block1[last_block]=0;
4635  //new_r->wvhdl[last_block]=NULL;
4636 
4637  rComplete(new_r, 1);
4638 
4639 #ifdef HAVE_PLURAL
4640  if (rIsPluralRing(r))
4641  {
4642  if ( nc_rComplete(r, new_r, false) ) // no qideal!
4643  {
4644 #ifndef SING_NDEBUG
4645  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4646 #endif
4647  }
4648  }
4649  assume(rIsPluralRing(r) == rIsPluralRing(new_r));
4650 #endif
4651 
4652  return new_r;
4653 }
#define omMemDup(s)
Definition: omAllocDecl.h:264

◆ rAssure_InducedSchreyerOrdering()

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

Definition at line 4811 of file ring.cc.

4812 { // TODO: ???? Add leading Syz-comp ordering here...????
4813 
4814 #if MYTEST
4815  Print("rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
4816  rWrite(r);
4817 #ifdef RDEBUG
4818  rDebugPrint(r);
4819 #endif
4820  PrintLn();
4821 #endif
4822  assume((sgn == 1) || (sgn == -1));
4823 
4824  ring res=rCopy0(r, FALSE, FALSE); // No qideal & ordering copy.
4825 
4826  int n = rBlocks(r); // Including trailing zero!
4827 
4828  // Create 2 more blocks for prefix/suffix:
4829  res->order=(rRingOrder_t *)omAlloc0((n+2)*sizeof(rRingOrder_t)); // 0 .. n+1
4830  res->block0=(int *)omAlloc0((n+2)*sizeof(int));
4831  res->block1=(int *)omAlloc0((n+2)*sizeof(int));
4832  int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
4833 
4834  // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
4835  // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
4836 
4837  // new 1st block
4838  int j = 0;
4839  res->order[j] = ringorder_IS; // Prefix
4840  res->block0[j] = res->block1[j] = 0;
4841  // wvhdl[j] = NULL;
4842  j++;
4843 
4844  for(int i = 0; (i <= n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
4845  {
4846  res->order [j] = r->order [i];
4847  res->block0[j] = r->block0[i];
4848  res->block1[j] = r->block1[i];
4849 
4850  if (r->wvhdl[i] != NULL)
4851  {
4852  wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
4853  } // else wvhdl[j] = NULL;
4854  }
4855 
4856  // new last block
4857  res->order [j] = ringorder_IS; // Suffix
4858  res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
4859  // wvhdl[j] = NULL;
4860  j++;
4861 
4862  // res->order [j] = 0; // The End!
4863  res->wvhdl = wvhdl;
4864 
4865  // j == the last zero block now!
4866  assume(j == (n+1));
4867  assume(res->order[0]==ringorder_IS);
4868  assume(res->order[j-1]==ringorder_IS);
4869  assume(res->order[j]==0);
4870 
4871 
4872  if (complete)
4873  {
4874  rComplete(res, 1);
4875 
4876 #ifdef HAVE_PLURAL
4877  if (rIsPluralRing(r))
4878  {
4879  if ( nc_rComplete(r, res, false) ) // no qideal!
4880  {
4881 #ifndef SING_NDEBUG
4882  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4883 #endif
4884  }
4885  }
4887 #endif
4888 
4889 
4890 #ifdef HAVE_PLURAL
4891  ring old_ring = r;
4892 #endif
4893 
4894  if (r->qideal!=NULL)
4895  {
4896  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4897 
4898  assume(id_RankFreeModule(res->qideal, res) == 0);
4899 
4900 #ifdef HAVE_PLURAL
4901  if( rIsPluralRing(res) )
4902  if( nc_SetupQuotient(res, r, true) )
4903  {
4904 // WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4905  }
4906 
4907 #endif
4908  assume(id_RankFreeModule(res->qideal, res) == 0);
4909  }
4910 
4911 #ifdef HAVE_PLURAL
4912  assume((res->qideal==NULL) == (old_ring->qideal==NULL));
4913  assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
4914  assume(rIsSCA(res) == rIsSCA(old_ring));
4915  assume(ncRingType(res) == ncRingType(old_ring));
4916 #endif
4917  }
4918 
4919  return res;
4920 }
int sgn(const Rational &a)
Definition: GMPrat.cc:430
static bool rIsSCA(const ring r)
Definition: nc.h:190
bool nc_SetupQuotient(ring rGR, const ring rG=NULL, bool bCopy=false)
Definition: old.gring.cc:3403
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:159
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:226
void rDebugPrint(const ring r)
Definition: ring.cc:4072
@ ringorder_IS
Induced (Schreyer) ordering.
Definition: ring.h:93
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s

◆ rAssure_SyzComp()

ring rAssure_SyzComp ( const ring  r,
BOOLEAN  complete 
)

Definition at line 4423 of file ring.cc.

4424 {
4425  if ( r->order[0] == ringorder_s ) return r;
4426 
4427  if ( r->order[0] == ringorder_IS )
4428  {
4429 #ifndef SING_NDEBUG
4430  WarnS("rAssure_SyzComp: input ring has an IS-ordering!");
4431 #endif
4432 // return r;
4433  }
4434  ring res=rCopy0(r, FALSE, FALSE);
4435  int i=rBlocks(r);
4436  int j;
4437 
4438  res->order=(rRingOrder_t *)omAlloc((i+1)*sizeof(rRingOrder_t));
4439  res->block0=(int *)omAlloc0((i+1)*sizeof(int));
4440  res->block1=(int *)omAlloc0((i+1)*sizeof(int));
4441  int ** wvhdl =(int **)omAlloc0((i+1)*sizeof(int**));
4442  for(j=i;j>0;j--)
4443  {
4444  res->order[j]=r->order[j-1];
4445  res->block0[j]=r->block0[j-1];
4446  res->block1[j]=r->block1[j-1];
4447  if (r->wvhdl[j-1] != NULL)
4448  {
4449  wvhdl[j] = (int*) omMemDup(r->wvhdl[j-1]);
4450  }
4451  }
4452  res->order[0]=ringorder_s;
4453 
4454  res->wvhdl = wvhdl;
4455 
4456  if (complete)
4457  {
4458  rComplete(res, 1);
4459 #ifdef HAVE_PLURAL
4460  if (rIsPluralRing(r))
4461  {
4462  if ( nc_rComplete(r, res, false) ) // no qideal!
4463  {
4464 #ifndef SING_NDEBUG
4465  WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4466 #endif
4467  }
4468  }
4470 #endif
4471 
4472 #ifdef HAVE_PLURAL
4473  ring old_ring = r;
4474 #endif
4475  if (r->qideal!=NULL)
4476  {
4477  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4478  assume(id_RankFreeModule(res->qideal, res) == 0);
4479 #ifdef HAVE_PLURAL
4480  if( rIsPluralRing(res) )
4481  {
4482  if( nc_SetupQuotient(res, r, true) )
4483  {
4484 // WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4485  }
4486  assume(id_RankFreeModule(res->qideal, res) == 0);
4487  }
4488 #endif
4489  }
4490 
4491 #ifdef HAVE_PLURAL
4492  assume((res->qideal==NULL) == (old_ring->qideal==NULL));
4493  assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
4494  assume(rIsSCA(res) == rIsSCA(old_ring));
4495  assume(ncRingType(res) == ncRingType(old_ring));
4496 #endif
4497  }
4498  return res;
4499 }
#define omAlloc(size)
Definition: omAllocDecl.h:210
@ ringorder_s
s?
Definition: ring.h:76

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

4711 {
4712  rTest(r);
4713 
4714  ring new_r_1 = rAssure_CompLastBlock(r, FALSE); // due to this FALSE - no completion!
4715  ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
4716 
4717  if (new_r == r)
4718  return r;
4719 
4720  ring old_r = r;
4721  if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
4722 
4723  rComplete(new_r, TRUE);
4724 #ifdef HAVE_PLURAL
4725  if (rIsPluralRing(old_r))
4726  {
4727  if ( nc_rComplete(old_r, new_r, false) ) // no qideal!
4728  {
4729 # ifndef SING_NDEBUG
4730  WarnS("error in nc_rComplete"); // cleanup? rDelete(res); return r; // just go on...?
4731 # endif
4732  }
4733  }
4734 #endif
4735 
4736 ///? rChangeCurrRing(new_r);
4737  if (old_r->qideal != NULL)
4738  {
4739  new_r->qideal = idrCopyR(old_r->qideal, old_r, new_r);
4740  }
4741 
4742 #ifdef HAVE_PLURAL
4743  if( rIsPluralRing(old_r) )
4744  if( nc_SetupQuotient(new_r, old_r, true) )
4745  {
4746 #ifndef SING_NDEBUG
4747  WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4748 #endif
4749  }
4750 #endif
4751 
4752 #ifdef HAVE_PLURAL
4753  assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
4754  assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
4755  assume(rIsSCA(new_r) == rIsSCA(old_r));
4756  assume(ncRingType(new_r) == ncRingType(old_r));
4757 #endif
4758 
4759  rTest(new_r);
4760  rTest(old_r);
4761  return new_r;
4762 }
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:191
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition: ring.cc:4423
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:449
ring rAssure_CompLastBlock(ring r, BOOLEAN complete)
makes sure that c/C ordering is last ordering
Definition: ring.cc:4655

◆ rAssure_SyzOrder()

ring rAssure_SyzOrder ( const ring  r,
BOOLEAN  complete 
)

Definition at line 4418 of file ring.cc.

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

◆ rAssure_TDeg()

ring rAssure_TDeg ( ring  r,
int &  pos 
)

Definition at line 4501 of file ring.cc.

4502 {
4503  if (r->N==1) // special: dp(1)==lp(1)== no entry in typ
4504  {
4505  pos=r->VarL_LowIndex;
4506  return r;
4507  }
4508  if (r->typ!=NULL)
4509  {
4510  for(int i=r->OrdSize-1;i>=0;i--)
4511  {
4512  if ((r->typ[i].ord_typ==ro_dp)
4513  && (r->typ[i].data.dp.start==1)
4514  && (r->typ[i].data.dp.end==r->N))
4515  {
4516  pos=r->typ[i].data.dp.place;
4517  //printf("no change, pos=%d\n",pos);
4518  return r;
4519  }
4520  }
4521  }
4522 
4523 #ifdef HAVE_PLURAL
4524  nc_struct* save=r->GetNC();
4525  r->GetNC()=NULL;
4526 #endif
4527  ring res=rCopy(r);
4528  if (res->qideal!=NULL)
4529  {
4530  id_Delete(&res->qideal,r);
4531  }
4532 
4533  int i=rBlocks(r);
4534  int j;
4535 
4536  res->ExpL_Size=r->ExpL_Size+1; // one word more in each monom
4537  res->PolyBin=omGetSpecBin(POLYSIZE + (res->ExpL_Size)*sizeof(long));
4538  omFree((ADDRESS)res->ordsgn);
4539  res->ordsgn=(long *)omAlloc0(res->ExpL_Size*sizeof(long));
4540  for(j=0;j<r->CmpL_Size;j++)
4541  {
4542  res->ordsgn[j] = r->ordsgn[j];
4543  }
4544  res->OrdSize=r->OrdSize+1; // one block more for pSetm
4545  if (r->typ!=NULL)
4546  omFree((ADDRESS)res->typ);
4547  res->typ=(sro_ord*)omAlloc0(res->OrdSize*sizeof(sro_ord));
4548  if (r->typ!=NULL)
4549  memcpy(res->typ,r->typ,r->OrdSize*sizeof(sro_ord));
4550  // the additional block for pSetm: total degree at the last word
4551  // but not included in the compare part
4552  res->typ[res->OrdSize-1].ord_typ=ro_dp;
4553  res->typ[res->OrdSize-1].data.dp.start=1;
4554  res->typ[res->OrdSize-1].data.dp.end=res->N;
4555  res->typ[res->OrdSize-1].data.dp.place=res->ExpL_Size-1;
4556  pos=res->ExpL_Size-1;
4557  //res->pOrdIndex=pos; //NO: think of a(1,0),dp !
4558  extern void p_Setm_General(poly p, ring r);
4559  res->p_Setm=p_Setm_General;
4560  // ----------------------------
4561  omFree((ADDRESS)res->p_Procs);
4562  res->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
4563 
4564  p_ProcsSet(res, res->p_Procs);
4565 #ifdef HAVE_PLURAL
4566  r->GetNC()=save;
4567  if (rIsPluralRing(r))
4568  {
4569  if ( nc_rComplete(r, res, false) ) // no qideal!
4570  {
4571 #ifndef SING_NDEBUG
4572  WarnS("error in nc_rComplete");
4573 #endif
4574  // just go on..
4575  }
4576  }
4577 #endif
4578  if (r->qideal!=NULL)
4579  {
4580  res->qideal=idrCopyR_NoSort(r->qideal,r, res);
4581 #ifdef HAVE_PLURAL
4582  if (rIsPluralRing(res))
4583  {
4584 // nc_SetupQuotient(res, currRing);
4585  nc_SetupQuotient(res, r); // ?
4586  }
4587  assume((res->qideal==NULL) == (r->qideal==NULL));
4588 #endif
4589  }
4590 
4591 #ifdef HAVE_PLURAL
4593  assume(rIsSCA(res) == rIsSCA(r));
4594  assume(ncRingType(res) == ncRingType(r));
4595 #endif
4596 
4597  return res;
4598 }
void * ADDRESS
Definition: auxiliary.h:119
#define POLYSIZE
Definition: monomials.h:233
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omGetSpecBin(size)
Definition: omBin.h:11
void p_ProcsSet(ring r, p_Procs_s *p_Procs)
Definition: p_Procs_Set.h:141
void p_Setm_General(poly p, const ring r)
Definition: p_polys.cc:157
struct p_Procs_s p_Procs_s
Definition: ring.h:23
@ ro_dp
Definition: ring.h:52
Definition: ring.h:219
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: nc.h:68

◆ rChangeSComps()

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

Definition at line 4393 of file ring.cc.

4394 {
4395 #ifdef PDEBUG
4396  rDBChangeSComps(currComponents, currShiftedComponents, length, r);
4397 #else
4398  rNChangeSComps(currComponents, currShiftedComponents, r);
4399 #endif
4400 }
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
Definition: ring.cc:4355
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4371
EXTERN_VAR long * currShiftedComponents
Definition: syz.h:118

◆ rChar()

int rChar ( ring  r)

Definition at line 711 of file ring.cc.

711 { 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 645 of file ring.cc.

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

◆ rCheckIV()

BOOLEAN rCheckIV ( const intvec iv)

Definition at line 175 of file ring.cc.

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

◆ rCheckOrdSgn()

static void rCheckOrdSgn ( ring  r,
int  i 
)
static

Definition at line 3802 of file ring.cc.

3803 { // set r->OrdSgn, r->MixedOrder
3804  // for each variable:
3805  int nonpos=0;
3806  int nonneg=0;
3807  for(int i=1;i<=r->N;i++)
3808  {
3809  int found=0;
3810  // for all blocks:
3811  for(int j=0;(j<=b) && (found==0);j++)
3812  {
3813  // search the first block containing var(i)
3814  if ((r->block0[j]<=i)&&(r->block1[j]>=i))
3815  {
3816  // what kind if block is it?
3817  if ((r->order[j]==ringorder_ls)
3818  || (r->order[j]==ringorder_ds)
3819  || (r->order[j]==ringorder_Ds)
3820  || (r->order[j]==ringorder_ws)
3821  || (r->order[j]==ringorder_Ws)
3822  || (r->order[j]==ringorder_rs))
3823  {
3824  r->OrdSgn=-1;
3825  nonpos++;
3826  found=1;
3827  }
3828  else if((r->order[j]==ringorder_a)
3829  ||(r->order[j]==ringorder_aa))
3830  {
3831  // <0: local/mixed ordering
3832  // >0: var(i) is okay, look at other vars
3833  // ==0: look at other blocks for var(i)
3834  if(r->wvhdl[j][i-r->block0[j]]<0)
3835  {
3836  r->OrdSgn=-1;
3837  nonpos++;
3838  found=1;
3839  }
3840  else if(r->wvhdl[j][i-r->block0[j]]>0)
3841  {
3842  nonneg++;
3843  found=1;
3844  }
3845  }
3846  else if(r->order[j]==ringorder_M)
3847  {
3848  // <0: local/mixed ordering
3849  // >0: var(i) is okay, look at other vars
3850  // ==0: look at other blocks for var(i)
3851  if(r->wvhdl[j][i-r->block0[j]]<0)
3852  {
3853  r->OrdSgn=-1;
3854  nonpos++;
3855  found=1;
3856  }
3857  else if(r->wvhdl[j][i-r->block0[j]]>0)
3858  {
3859  nonneg++;
3860  found=1;
3861  }
3862  else
3863  {
3864  // very bad: try next row(s)
3865  int add=r->block1[j]-r->block0[j]+1;
3866  int max_i=r->block0[j]+add*add-add-1;
3867  while(found==0)
3868  {
3869  i+=add;
3870  if (r->wvhdl[j][i-r->block0[j]]<0)
3871  {
3872  r->OrdSgn=-1;
3873  nonpos++;
3874  found=1;
3875  }
3876  else if(r->wvhdl[j][i-r->block0[j]]>0)
3877  {
3878  nonneg++;
3879  found=1;
3880  }
3881  else if(i>max_i)
3882  {
3883  nonpos++;
3884  nonneg++;
3885  found=1;
3886  }
3887  }
3888  }
3889  }
3890  else if ((r->order[j]==ringorder_lp)
3891  || (r->order[j]==ringorder_dp)
3892  || (r->order[j]==ringorder_Dp)
3893  || (r->order[j]==ringorder_wp)
3894  || (r->order[j]==ringorder_Wp)
3895  || (r->order[j]==ringorder_rp))
3896  {
3897  found=1;
3898  nonneg++;
3899  }
3900  }
3901  }
3902  }
3903  if (nonpos>0)
3904  {
3905  r->OrdSgn=-1;
3906  if (nonneg>0) r->MixedOrder=1;
3907  }
3908  else
3909  {
3910  r->OrdSgn=1;
3911  r->MixedOrder=0;
3912  }
3913 }
CanonicalForm b
Definition: cfModGcd.cc:4105
bool found
Definition: facFactorize.cc:55
STATIC_VAR unsigned add[]
Definition: misc_ip.cc:115
@ ringorder_lp
Definition: ring.h:77
@ ringorder_a
Definition: ring.h:70
@ ringorder_rs
opposite of ls
Definition: ring.h:92
@ ringorder_ds
Definition: ring.h:84
@ ringorder_Dp
Definition: ring.h:80
@ ringorder_Ds
Definition: ring.h:85
@ ringorder_rp
Definition: ring.h:79
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition: ring.h:91
@ ringorder_Wp
Definition: ring.h:82
@ ringorder_ws
Definition: ring.h:86
@ ringorder_Ws
Definition: ring.h:87
@ ringorder_ls
Definition: ring.h:83
@ ringorder_wp
Definition: ring.h:81
@ ringorder_M
Definition: ring.h:74

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

3401 {
3402  if (r->VarOffset!=NULL && force == 0) return FALSE;
3403  rSetOutParams(r);
3404  int n=rBlocks(r)-1;
3405  int i;
3406  int bits;
3407  r->bitmask=rGetExpSize(r->wanted_maxExp,bits,r->N);
3408  r->BitsPerExp = bits;
3409  r->ExpPerLong = BIT_SIZEOF_LONG / bits;
3410  r->divmask=rGetDivMask(bits);
3411 
3412  // will be used for ordsgn:
3413  long *tmp_ordsgn=(long *)omAlloc0(3*(n+r->N)*sizeof(long));
3414  // will be used for VarOffset:
3415  int *v=(int *)omAlloc((r->N+1)*sizeof(int));
3416  for(i=r->N; i>=0 ; i--)
3417  {
3418  v[i]=-1;
3419  }
3420  sro_ord *tmp_typ=(sro_ord *)omAlloc0(3*(n+r->N)*sizeof(sro_ord));
3421  int typ_i=0;
3422  int prev_ordsgn=0;
3423 
3424  // fill in v, tmp_typ, tmp_ordsgn, determine typ_i (== ordSize)
3425  int j=0;
3426  int j_bits=BITS_PER_LONG;
3427 
3428  BOOLEAN need_to_add_comp=FALSE; // Only for ringorder_s and ringorder_S!
3429 
3430  for(i=0;i<n;i++)
3431  {
3432  tmp_typ[typ_i].order_index=i;
3433  switch (r->order[i])
3434  {
3435  case ringorder_a:
3436  case ringorder_aa:
3437  rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3438  r->wvhdl[i]);
3439  typ_i++;
3440  break;
3441 
3442  case ringorder_am:
3443  rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
3444  r->wvhdl[i]);
3445  typ_i++;
3446  break;
3447 
3448  case ringorder_a64:
3449  rO_WDegree64(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3450  tmp_typ[typ_i], (int64 *)(r->wvhdl[i]));
3451  typ_i++;
3452  break;
3453 
3454  case ringorder_c:
3455  rO_Align(j, j_bits);
3456  rO_LexVars_neg(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3457  r->ComponentOrder=1;
3458  break;
3459 
3460  case ringorder_C:
3461  rO_Align(j, j_bits);
3462  rO_LexVars(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3463  r->ComponentOrder=-1;
3464  break;
3465 
3466  case ringorder_M:
3467  {
3468  int k,l;
3469  k=r->block1[i]-r->block0[i]+1; // number of vars
3470  for(l=0;l<k;l++)
3471  {
3472  rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3473  tmp_typ[typ_i],
3474  r->wvhdl[i]+(r->block1[i]-r->block0[i]+1)*l);
3475  typ_i++;
3476  }
3477  break;
3478  }
3479 
3480  case ringorder_lp:
3481  rO_LexVars(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3482  tmp_ordsgn,v,bits, -1);
3483  break;
3484 
3485  case ringorder_ls:
3486  rO_LexVars_neg(j, j_bits, r->block0[i],r->block1[i], prev_ordsgn,
3487  tmp_ordsgn,v, bits, -1);
3488  break;
3489 
3490  case ringorder_rs:
3491  rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3492  tmp_ordsgn,v, bits, -1);
3493  break;
3494 
3495  case ringorder_rp:
3496  rO_LexVars(j, j_bits, r->block1[i],r->block0[i], prev_ordsgn,
3497  tmp_ordsgn,v, bits, -1);
3498  break;
3499 
3500  case ringorder_dp:
3501  if (r->block0[i]==r->block1[i])
3502  {
3503  rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3504  tmp_ordsgn,v, bits, -1);
3505  }
3506  else
3507  {
3508  rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3509  tmp_typ[typ_i]);
3510  typ_i++;
3511  rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
3512  prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3513  }
3514  break;
3515 
3516  case ringorder_Dp:
3517  if (r->block0[i]==r->block1[i])
3518  {
3519  rO_LexVars(j, j_bits, r->block0[i],r->block0[i], prev_ordsgn,
3520  tmp_ordsgn,v, bits, -1);
3521  }
3522  else
3523  {
3524  rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3525  tmp_typ[typ_i]);
3526  typ_i++;
3527  rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3528  tmp_ordsgn,v, bits, r->block1[i]);
3529  }
3530  break;
3531 
3532  case ringorder_ds:
3533  if (r->block0[i]==r->block1[i])
3534  {
3535  rO_LexVars_neg(j, j_bits,r->block0[i],r->block1[i],prev_ordsgn,
3536  tmp_ordsgn,v,bits, -1);
3537  }
3538  else
3539  {
3540  rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3541  tmp_typ[typ_i]);
3542  typ_i++;
3543  rO_LexVars_neg(j, j_bits, r->block1[i],r->block0[i]+1,
3544  prev_ordsgn,tmp_ordsgn,v,bits, r->block0[i]);
3545  }
3546  break;
3547 
3548  case ringorder_Ds:
3549  if (r->block0[i]==r->block1[i])
3550  {
3551  rO_LexVars_neg(j, j_bits, r->block0[i],r->block0[i],prev_ordsgn,
3552  tmp_ordsgn,v, bits, -1);
3553  }
3554  else
3555  {
3556  rO_TDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3557  tmp_typ[typ_i]);
3558  typ_i++;
3559  rO_LexVars(j, j_bits, r->block0[i],r->block1[i]-1, prev_ordsgn,
3560  tmp_ordsgn,v, bits, r->block1[i]);
3561  }
3562  break;
3563 
3564  case ringorder_wp:
3565  rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3566  tmp_typ[typ_i], r->wvhdl[i]);
3567  typ_i++;
3568  { // check for weights <=0
3569  int jj;
3570  BOOLEAN have_bad_weights=FALSE;
3571  for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3572  {
3573  if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
3574  }
3575  if (have_bad_weights)
3576  {
3577  rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3578  tmp_typ[typ_i]);
3579  typ_i++;
3580  }
3581  }
3582  if (r->block1[i]!=r->block0[i])
3583  {
3584  rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3585  tmp_ordsgn, v,bits, r->block0[i]);
3586  }
3587  break;
3588 
3589  case ringorder_Wp:
3590  rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3591  tmp_typ[typ_i], r->wvhdl[i]);
3592  typ_i++;
3593  { // check for weights <=0
3594  int jj;
3595  BOOLEAN have_bad_weights=FALSE;
3596  for(jj=r->block1[i]-r->block0[i];jj>=0; jj--)
3597  {
3598  if (r->wvhdl[i][jj]<=0) have_bad_weights=TRUE;
3599  }
3600  if (have_bad_weights)
3601  {
3602  rO_TDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3603  tmp_typ[typ_i]);
3604  typ_i++;
3605  }
3606  }
3607  if (r->block1[i]!=r->block0[i])
3608  {
3609  rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3610  tmp_ordsgn,v, bits, r->block1[i]);
3611  }
3612  break;
3613 
3614  case ringorder_ws:
3615  rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3616  tmp_typ[typ_i], r->wvhdl[i]);
3617  typ_i++;
3618  if (r->block1[i]!=r->block0[i])
3619  {
3620  rO_LexVars_neg(j, j_bits,r->block1[i],r->block0[i]+1, prev_ordsgn,
3621  tmp_ordsgn, v,bits, r->block0[i]);
3622  }
3623  break;
3624 
3625  case ringorder_Ws:
3626  rO_WDegree_neg(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,
3627  tmp_typ[typ_i], r->wvhdl[i]);
3628  typ_i++;
3629  if (r->block1[i]!=r->block0[i])
3630  {
3631  rO_LexVars(j, j_bits,r->block0[i],r->block1[i]-1, prev_ordsgn,
3632  tmp_ordsgn,v, bits, r->block1[i]);
3633  }
3634  break;
3635 
3636  case ringorder_S:
3637  assume(typ_i == 1); // For LaScala3 only: on the 2nd place ([1])!
3638  // TODO: for K[x]: it is 0...?!
3639  rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
3640  need_to_add_comp=TRUE;
3641  r->ComponentOrder=-1;
3642  typ_i++;
3643  break;
3644 
3645  case ringorder_s:
3646  assume(typ_i == 0 && j == 0);
3647  rO_Syz(j, j_bits, prev_ordsgn, r->block0[i], tmp_ordsgn, tmp_typ[typ_i]); // set syz-limit?
3648  need_to_add_comp=TRUE;
3649  r->ComponentOrder=-1;
3650  typ_i++;
3651  break;
3652 
3653  case ringorder_IS:
3654  {
3655 
3656  assume( r->block0[i] == r->block1[i] );
3657  const int s = r->block0[i];
3658  assume( -2 < s && s < 2);
3659 
3660  if(s == 0) // Prefix IS
3661  rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]); // What about prev_ordsgn?
3662  else // s = +1 or -1 // Note: typ_i might be incrimented here inside!
3663  {
3664  rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s); // Suffix.
3665  need_to_add_comp=FALSE;
3666  }
3667 
3668  break;
3669  }
3670  case ringorder_unspec:
3671  case ringorder_no:
3672  default:
3673  dReportError("undef. ringorder used\n");
3674  break;
3675  }
3676  }
3677  rCheckOrdSgn(r,n-1);
3678 
3679  int j0=j; // save j
3680  int j_bits0=j_bits; // save jbits
3681  rO_Align(j,j_bits);
3682  r->CmpL_Size = j;
3683 
3684  j_bits=j_bits0; j=j0;
3685 
3686  // fill in some empty slots with variables not already covered
3687  // v0 is special, is therefore normally already covered
3688  // now we do have rings without comp...
3689  if((need_to_add_comp) && (v[0]== -1))
3690  {
3691  if (prev_ordsgn==1)
3692  {
3693  rO_Align(j, j_bits);
3694  rO_LexVars(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3695  }
3696  else
3697  {
3698  rO_Align(j, j_bits);
3699  rO_LexVars_neg(j, j_bits, 0,0, prev_ordsgn,tmp_ordsgn,v,BITS_PER_LONG, -1);
3700  }
3701  }
3702  // the variables
3703  for(i=1 ; i<=r->N ; i++)
3704  {
3705  if(v[i]==(-1))
3706  {
3707  if (prev_ordsgn==1)
3708  {
3709  rO_LexVars(j, j_bits, i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3710  }
3711  else
3712  {
3713  rO_LexVars_neg(j,j_bits,i,i, prev_ordsgn,tmp_ordsgn,v,bits, -1);
3714  }
3715  }
3716  }
3717 
3718  rO_Align(j,j_bits);
3719  // ----------------------------
3720  // finished with constructing the monomial, computing sizes:
3721 
3722  r->ExpL_Size=j;
3723  r->PolyBin = omGetSpecBin(POLYSIZE + (r->ExpL_Size)*sizeof(long));
3724  assume(r->PolyBin != NULL);
3725 
3726  // ----------------------------
3727  // indices and ordsgn vector for comparison
3728  //
3729  // r->pCompHighIndex already set
3730  r->ordsgn=(long *)omAlloc0(r->ExpL_Size*sizeof(long));
3731 
3732  for(j=0;j<r->CmpL_Size;j++)
3733  {
3734  r->ordsgn[j] = tmp_ordsgn[j];
3735  }
3736 
3737  omFreeSize((ADDRESS)tmp_ordsgn,(3*(n+r->N)*sizeof(long)));
3738 
3739  // ----------------------------
3740  // description of orderings for setm:
3741  //
3742  r->OrdSize=typ_i;
3743  if (typ_i==0) r->typ=NULL;
3744  else
3745  {
3746  r->typ=(sro_ord*)omAlloc(typ_i*sizeof(sro_ord));
3747  memcpy(r->typ,tmp_typ,typ_i*sizeof(sro_ord));
3748  }
3749  omFreeSize((ADDRESS)tmp_typ,(3*(n+r->N)*sizeof(sro_ord)));
3750 
3751  // ----------------------------
3752  // indices for (first copy of ) variable entries in exp.e vector (VarOffset):
3753  r->VarOffset=v;
3754 
3755  // ----------------------------
3756  // other indicies
3757  r->pCompIndex=(r->VarOffset[0] & 0xffff); //r->VarOffset[0];
3758  i=0; // position
3759  j=0; // index in r->typ
3760  if (i==r->pCompIndex) i++; // IS???
3761  while ((j < r->OrdSize)
3762  && ((r->typ[j].ord_typ==ro_syzcomp) ||
3763  (r->typ[j].ord_typ==ro_syz) || (r->typ[j].ord_typ==ro_isTemp) || (r->typ[j].ord_typ==ro_is) ||
3764  (r->order[r->typ[j].order_index] == ringorder_aa)))
3765  {
3766  i++; j++;
3767  }
3768 
3769  if (i==r->pCompIndex) i++;
3770  r->pOrdIndex=i;
3771 
3772  // ----------------------------
3773  rSetDegStuff(r); // OrdSgn etc already set
3774  rSetOption(r);
3775  // ----------------------------
3776  // r->p_Setm
3777  r->p_Setm = p_GetSetmProc(r);
3778 
3779  // ----------------------------
3780  // set VarL_*
3781  rSetVarL(r);
3782 
3783  // ----------------------------
3784  // right-adjust VarOffset
3786 
3787  // ----------------------------
3788  // set NegWeightL*
3789  rSetNegWeight(r);
3790 
3791  // ----------------------------
3792  // p_Procs: call AFTER NegWeightL
3793  r->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
3794  p_ProcsSet(r, r->p_Procs);
3795 
3796  // use totaldegree on crazy oderings:
3797  if ((r->pFDeg==p_WTotaldegree) && rOrd_is_MixedDegree_Ordering(r))
3798  r->pFDeg = p_Totaldegree;
3799  return FALSE;
3800 }
long int64
Definition: auxiliary.h:68
#define BIT_SIZEOF_LONG
Definition: auxiliary.h:80
int BOOLEAN
Definition: auxiliary.h:87
int l
Definition: cfEzgcd.cc:100
int k
Definition: cfEzgcd.cc:99
const CanonicalForm int s
Definition: facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
int dReportError(const char *fmt,...)
Definition: dError.cc:43
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
long p_WTotaldegree(poly p, const ring r)
Definition: p_polys.cc:608
p_SetmProc p_GetSetmProc(const ring r)
Definition: p_polys.cc:555
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1467
static void rSetNegWeight(ring r)
Definition: ring.cc:3297
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:2419
static void rSetOption(ring r)
Definition: ring.cc:3334
#define BITS_PER_LONG
Definition: ring.cc:40
static void rO_WDegree64(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
Definition: ring.cc:2240
static void rSetVarL(ring r)
set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
Definition: ring.cc:3977
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:2284
BOOLEAN rOrd_is_MixedDegree_Ordering(ring r)
Definition: ring.cc:3378
static void rSetOutParams(ring r)
Definition: ring.cc:3025
static void rSetDegStuff(ring r)
Definition: ring.cc:3127
static void rO_WDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2258
static void rO_Syzcomp(int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
Definition: ring.cc:2360
static void rO_TDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition: ring.cc:2150
static void rO_WMDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2218
static void rO_Syz(int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
Definition: ring.cc:2375
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
Definition: ring.cc:2510
static void rCheckOrdSgn(ring r, int i)
Definition: ring.cc:3802
static unsigned long rGetDivMask(int bits)
get r->divmask depending on bits per exponent
Definition: ring.cc:4058
static void rRightAdjustVarOffset(ring r)
right-adjust r->VarOffset
Definition: ring.cc:4032
static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord, long *o, int, int *v, sro_ord &ord_struct)
Definition: ring.cc:2401
static void rO_Align(int &place, int &bitplace)
Definition: ring.cc:2139
static void rO_TDegree_neg(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
Definition: ring.cc:2164
static void rO_WDegree(int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
Definition: ring.cc:2178
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:2321
@ ro_syz
Definition: ring.h:60
@ ro_is
Definition: ring.h:61
@ ro_isTemp
Definition: ring.h:61
@ ro_syzcomp
Definition: ring.h:59
@ ringorder_am
Definition: ring.h:88
@ ringorder_a64
for int64 weights
Definition: ring.h:71
@ ringorder_unspec
Definition: ring.h:94
@ ringorder_no
Definition: ring.h:69
int order_index
Definition: ring.h:221

◆ rCopy()

ring rCopy ( ring  r)

Definition at line 1645 of file ring.cc.

1646 {
1647  if (r == NULL) return NULL;
1648  ring res=rCopy0(r,FALSE,TRUE);
1649  rComplete(res, 1); // res is purely commutative so far
1650  if (r->qideal!=NULL) res->qideal=idrCopyR_NoSort(r->qideal, r, res);
1651 
1652 #ifdef HAVE_PLURAL
1653  if (rIsPluralRing(r))
1654  if( nc_rCopy(res, r, true) ) {}
1655 #endif
1656 
1657  return res;
1658 }
bool nc_rCopy(ring res, const ring r, bool bSetupQuotient)
Definition: old.gring.cc:3003

◆ rCopy0()

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

Definition at line 1363 of file ring.cc.

1364 {
1365  if (r == NULL) return NULL;
1366  int i,j;
1367  ring res=(ring)omAlloc0Bin(sip_sring_bin);
1368  //memset: res->idroot=NULL; /* local objects */
1369  //ideal minideal;
1370  res->options=r->options; /* ring dependent options */
1371 
1372  //memset: res->ordsgn=NULL;
1373  //memset: res->typ=NULL;
1374  //memset: res->VarOffset=NULL;
1375  //memset: res->firstwv=NULL;
1376 
1377  //struct omBin PolyBin; /* Bin from where monoms are allocated */
1378  //memset: res->PolyBin=NULL; // rComplete
1379  res->cf=nCopyCoeff(r->cf); /* coeffs */
1380 
1381  //memset: res->ref=0; /* reference counter to the ring */
1382 
1383  res->N=rVar(r); /* number of vars */
1384 
1385  res->firstBlockEnds=r->firstBlockEnds;
1386 #ifdef HAVE_PLURAL
1387  res->real_var_start=r->real_var_start;
1388  res->real_var_end=r->real_var_end;
1389 #endif
1390 
1391 #ifdef HAVE_SHIFTBBA
1392  res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
1393  res->LPncGenCount=r->LPncGenCount;
1394 #endif
1395 
1396  res->VectorOut=r->VectorOut;
1397  res->ShortOut=r->ShortOut;
1398  res->CanShortOut=r->CanShortOut;
1399 
1400  //memset: res->ExpL_Size=0;
1401  //memset: res->CmpL_Size=0;
1402  //memset: res->VarL_Size=0;
1403  //memset: res->pCompIndex=0;
1404  //memset: res->pOrdIndex=0;
1405  //memset: res->OrdSize=0;
1406  //memset: res->VarL_LowIndex=0;
1407  //memset: res->NegWeightL_Size=0;
1408  //memset: res->NegWeightL_Offset=NULL;
1409  //memset: res->VarL_Offset=NULL;
1410 
1411  // the following are set by rComplete unless predefined
1412  // therefore, we copy these values: maybe they are non-standard
1413  /* mask for getting single exponents */
1414  res->bitmask=r->bitmask;
1415  res->divmask=r->divmask;
1416  res->BitsPerExp = r->BitsPerExp;
1417  res->ExpPerLong = r->ExpPerLong;
1418 
1419  //memset: res->p_Procs=NULL;
1420  //memset: res->pFDeg=NULL;
1421  //memset: res->pLDeg=NULL;
1422  //memset: res->pFDegOrig=NULL;
1423  //memset: res->pLDegOrig=NULL;
1424  //memset: res->p_Setm=NULL;
1425  //memset: res->cf=NULL;
1426 
1427 /*
1428  if (r->extRing!=NULL)
1429  r->extRing->ref++;
1430 
1431  res->extRing=r->extRing;
1432  //memset: res->qideal=NULL;
1433 */
1434 
1435 
1436  if (copy_ordering == TRUE)
1437  {
1438  res->LexOrder=r->LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
1439  res->MixedOrder=r->MixedOrder; // TRUE for mixed (global/local) ordering, FALSE otherwise,
1440  i=rBlocks(r);
1441  res->wvhdl = (int **)omAlloc(i * sizeof(int *));
1442  res->order = (rRingOrder_t *) omAlloc(i * sizeof(rRingOrder_t));
1443  res->block0 = (int *) omAlloc(i * sizeof(int));
1444  res->block1 = (int *) omAlloc(i * sizeof(int));
1445  for (j=0; j<i; j++)
1446  {
1447  if (r->wvhdl[j]!=NULL)
1448  {
1449  res->wvhdl[j] = (int*) omMemDup(r->wvhdl[j]);
1450  }
1451  else
1452  res->wvhdl[j]=NULL;
1453  }
1454  memcpy(res->order,r->order,i * sizeof(rRingOrder_t));
1455  memcpy(res->block0,r->block0,i * sizeof(int));
1456  memcpy(res->block1,r->block1,i * sizeof(int));
1457  }
1458  //memset: else
1459  //memset: {
1460  //memset: res->wvhdl = NULL;
1461  //memset: res->order = NULL;
1462  //memset: res->block0 = NULL;
1463  //memset: res->block1 = NULL;
1464  //memset: }
1465 
1466  res->names = (char **)omAlloc0(rVar(r) * sizeof(char *));
1467  for (i=0; i<rVar(res); i++)
1468  {
1469  res->names[i] = omStrDup(r->names[i]);
1470  }
1471  if (r->qideal!=NULL)
1472  {
1473  if (copy_qideal)
1474  {
1475  assume(copy_ordering);
1476  rComplete(res);
1477  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
1478  rUnComplete(res);
1479  }
1480  //memset: else res->qideal = NULL;
1481  }
1482  //memset: else res->qideal = NULL;
1483  //memset: res->GetNC() = NULL; // copy is purely commutative!!!
1484  return res;
1485 }
static FORCE_INLINE coeffs nCopyCoeff(const coeffs r)
"copy" coeffs, i.e. increment ref
Definition: coeffs.h:430
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
VAR omBin sip_sring_bin
Definition: ring.cc:43
void rUnComplete(ring r)
Definition: ring.cc:3915
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:594

◆ rCopy0AndAddA()

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

Definition at line 1492 of file ring.cc.

1493 {
1494  if (r == NULL) return NULL;
1495  int i,j;
1496  ring res=(ring)omAlloc0Bin(sip_sring_bin);
1497  //memcpy(res,r,sizeof(ip_sring));
1498  //memset: res->idroot=NULL; /* local objects */
1499  //ideal minideal;
1500  res->options=r->options; /* ring dependent options */
1501 
1502  //memset: res->ordsgn=NULL;
1503  //memset: res->typ=NULL;
1504  //memset: res->VarOffset=NULL;
1505  //memset: res->firstwv=NULL;
1506 
1507  //struct omBin PolyBin; /* Bin from where monoms are allocated */
1508  //memset: res->PolyBin=NULL; // rComplete
1509  res->cf=nCopyCoeff(r->cf); /* coeffs */
1510 
1511  //memset: res->ref=0; /* reference counter to the ring */
1512 
1513  res->N=rVar(r); /* number of vars */
1514 
1515  res->firstBlockEnds=r->firstBlockEnds;
1516 #ifdef HAVE_PLURAL
1517  res->real_var_start=r->real_var_start;
1518  res->real_var_end=r->real_var_end;
1519 #endif
1520 
1521 #ifdef HAVE_SHIFTBBA
1522  res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
1523  res->LPncGenCount=r->LPncGenCount;
1524 #endif
1525 
1526  res->VectorOut=r->VectorOut;
1527  res->ShortOut=r->ShortOut;
1528  res->CanShortOut=r->CanShortOut;
1529  res->LexOrder=r->LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
1530  res->MixedOrder=r->MixedOrder; // TRUE for mixed (global/local) ordering, FALSE otherwise,
1531 
1532  //memset: res->ExpL_Size=0;
1533  //memset: res->CmpL_Size=0;
1534  //memset: res->VarL_Size=0;
1535  //memset: res->pCompIndex=0;
1536  //memset: res->pOrdIndex=0;
1537  //memset: res->OrdSize=0;
1538  //memset: res->VarL_LowIndex=0;
1539  //memset: res->NegWeightL_Size=0;
1540  //memset: res->NegWeightL_Offset=NULL;
1541  //memset: res->VarL_Offset=NULL;
1542 
1543  // the following are set by rComplete unless predefined
1544  // therefore, we copy these values: maybe they are non-standard
1545  /* mask for getting single exponents */
1546  res->bitmask=r->bitmask;
1547  res->divmask=r->divmask;
1548  res->BitsPerExp = r->BitsPerExp;
1549  res->ExpPerLong = r->ExpPerLong;
1550 
1551  //memset: res->p_Procs=NULL;
1552  //memset: res->pFDeg=NULL;
1553  //memset: res->pLDeg=NULL;
1554  //memset: res->pFDegOrig=NULL;
1555  //memset: res->pLDegOrig=NULL;
1556  //memset: res->p_Setm=NULL;
1557  //memset: res->cf=NULL;
1558 
1559 /*
1560  if (r->extRing!=NULL)
1561  r->extRing->ref++;
1562 
1563  res->extRing=r->extRing;
1564  //memset: res->qideal=NULL;
1565 */
1566 
1567 
1568  if (copy_ordering == TRUE)
1569  {
1570  i=rBlocks(r)+1; // DIFF to rCopy0
1571  res->wvhdl = (int **)omAlloc(i * sizeof(int *));
1572  res->order = (rRingOrder_t *) omAlloc(i * sizeof(rRingOrder_t));
1573  res->block0 = (int *) omAlloc(i * sizeof(int));
1574  res->block1 = (int *) omAlloc(i * sizeof(int));
1575  for (j=0; j<i-1; j++)
1576  {
1577  if (r->wvhdl[j]!=NULL)
1578  {
1579  res->wvhdl[j+1] = (int*) omMemDup(r->wvhdl[j]); //DIFF
1580  }
1581  else
1582  res->wvhdl[j+1]=NULL; //DIFF
1583  }
1584  memcpy(&(res->order[1]),r->order,(i-1) * sizeof(rRingOrder_t)); //DIFF
1585  memcpy(&(res->block0[1]),r->block0,(i-1) * sizeof(int)); //DIFF
1586  memcpy(&(res->block1[1]),r->block1,(i-1) * sizeof(int)); //DIFF
1587  }
1588  //memset: else
1589  //memset: {
1590  //memset: res->wvhdl = NULL;
1591  //memset: res->order = NULL;
1592  //memset: res->block0 = NULL;
1593  //memset: res->block1 = NULL;
1594  //memset: }
1595 
1596  //the added A
1597  res->order[0]=ringorder_a64;
1598  int length=wv64->rows();
1599  int64 *A=(int64 *)omAlloc(length*sizeof(int64));
1600  for(j=length-1;j>=0;j--)
1601  {
1602  A[j]=(*wv64)[j];
1603  }
1604  res->wvhdl[0]=(int *)A;
1605  res->block0[0]=1;
1606  res->block1[0]=length;
1607  //
1608 
1609  res->names = (char **)omAlloc0(rVar(r) * sizeof(char *));
1610  for (i=0; i<rVar(res); i++)
1611  {
1612  res->names[i] = omStrDup(r->names[i]);
1613  }
1614  if (r->qideal!=NULL)
1615  {
1616  if (copy_qideal)
1617  {
1618  #ifndef SING_NDEBUG
1619  if (!copy_ordering)
1620  WerrorS("internal error: rCopy0(Q,TRUE,FALSE)");
1621  else
1622  #endif
1623  {
1624  #ifndef SING_NDEBUG
1625  WarnS("internal bad stuff: rCopy0(Q,TRUE,TRUE)");
1626  #endif
1627  rComplete(res);
1628  res->qideal= idrCopyR_NoSort(r->qideal, r, res);
1629  rUnComplete(res);
1630  }
1631  }
1632  //memset: else res->qideal = NULL;
1633  }
1634  //memset: else res->qideal = NULL;
1635  //memset: res->GetNC() = NULL; // copy is purely commutative!!!
1636  return res;
1637 }
int rows() const
Definition: int64vec.h:66
#define A
Definition: sirandom.c:24

◆ rDBChangeSComps()

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

Definition at line 4371 of file ring.cc.

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

◆ rDBGetSComps()

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

Definition at line 4381 of file ring.cc.

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

◆ rDBTest()

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

Definition at line 1989 of file ring.cc.

1990 {
1991  int i,j;
1992 
1993  if (r == NULL)
1994  {
1995  dReportError("Null ring in %s:%d", fn, l);
1996  return FALSE;
1997  }
1998 
1999 
2000  if (r->N == 0) return TRUE;
2001 
2002  if ((r->OrdSgn!=1) && (r->OrdSgn!= -1))
2003  {
2004  dReportError("missing OrdSgn in %s:%d", fn, l);
2005  return FALSE;
2006  }
2007 
2008 // omCheckAddrSize(r,sizeof(ip_sring));
2009 #if OM_CHECK > 0
2010  i=rBlocks(r);
2011  omCheckAddrSize(r->order,i*sizeof(int));
2012  omCheckAddrSize(r->block0,i*sizeof(int));
2013  omCheckAddrSize(r->block1,i*sizeof(int));
2014  for(int j=0;j<=i;j++)
2015  {
2016  if((r->order[j]<0)||(r->order[j]>ringorder_unspec))
2017  dError("wrong order in r->order");
2018  }
2019  if (r->wvhdl!=NULL)
2020  {
2021  omCheckAddrSize(r->wvhdl,i*sizeof(int *));
2022  for (j=0;j<i; j++)
2023  {
2024  if (r->wvhdl[j] != NULL) omCheckAddr(r->wvhdl[j]);
2025  }
2026  }
2027 #endif
2028  if (r->VarOffset == NULL)
2029  {
2030  dReportError("Null ring VarOffset -- no rComplete (?) in n %s:%d", fn, l);
2031  return FALSE;
2032  }
2033  omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(int));
2034 
2035  if ((r->OrdSize==0)!=(r->typ==NULL))
2036  {
2037  dReportError("mismatch OrdSize and typ-pointer in %s:%d");
2038  return FALSE;
2039  }
2040  omcheckAddrSize(r->typ,r->OrdSize*sizeof(*(r->typ)));
2041  omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(*(r->VarOffset)));
2042  // test assumptions:
2043  for(i=0;i<=r->N;i++) // for all variables (i = 0..N)
2044  {
2045  if(r->typ!=NULL)
2046  {
2047  for(j=0;j<r->OrdSize;j++) // for all ordering blocks (j =0..OrdSize-1)
2048  {
2049  if(r->typ[j].ord_typ == ro_isTemp)
2050  {
2051  const int p = r->typ[j].data.isTemp.suffixpos;
2052 
2053  if(p <= j)
2054  dReportError("ordrec prefix %d is unmatched",j);
2055 
2056  assume( p < r->OrdSize );
2057 
2058  if(r->typ[p].ord_typ != ro_is)
2059  dReportError("ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
2060 
2061  // Skip all intermediate blocks for undone variables:
2062  if(r->typ[j].data.isTemp.pVarOffset[i] != -1) // Check i^th variable
2063  {
2064  j = p - 1; // SKIP ALL INTERNAL BLOCKS...???
2065  continue; // To make for check OrdSize bound...
2066  }
2067  }
2068  else if (r->typ[j].ord_typ == ro_is)
2069  {
2070  // Skip all intermediate blocks for undone variables:
2071  if(r->typ[j].data.is.pVarOffset[i] != -1)
2072  {
2073  // TODO???
2074  }
2075 
2076  }
2077  else
2078  {
2079  if (r->typ[j].ord_typ==ro_cp)
2080  {
2081  if(((short)r->VarOffset[i]) == r->typ[j].data.cp.place)
2082  dReportError("ordrec %d conflicts with var %d",j,i);
2083  }
2084  else
2085  if ((r->typ[j].ord_typ!=ro_syzcomp)
2086  && (r->VarOffset[i] == r->typ[j].data.dp.place))
2087  dReportError("ordrec %d conflicts with var %d",j,i);
2088  }
2089  }
2090  }
2091  int tmp;
2092  tmp=r->VarOffset[i] & 0xffffff;
2093  #if SIZEOF_LONG == 8
2094  if ((r->VarOffset[i] >> 24) >63)
2095  #else
2096  if ((r->VarOffset[i] >> 24) >31)
2097  #endif
2098  dReportError("bit_start out of range:%d",r->VarOffset[i] >> 24);
2099  if (i > 0 && ((tmp<0) ||(tmp>r->ExpL_Size-1)))
2100  {
2101  dReportError("varoffset out of range for var %d: %d",i,tmp);
2102  }
2103  }
2104  if(r->typ!=NULL)
2105  {
2106  for(j=0;j<r->OrdSize;j++)
2107  {
2108  if ((r->typ[j].ord_typ==ro_dp)
2109  || (r->typ[j].ord_typ==ro_wp)
2110  || (r->typ[j].ord_typ==ro_wp_neg))
2111  {
2112  if (r->typ[j].data.dp.start > r->typ[j].data.dp.end)
2113  dReportError("in ordrec %d: start(%d) > end(%d)",j,
2114  r->typ[j].data.dp.start, r->typ[j].data.dp.end);
2115  if ((r->typ[j].data.dp.start < 1)
2116  || (r->typ[j].data.dp.end > r->N))
2117  dReportError("in ordrec %d: start(%d)<1 or end(%d)>vars(%d)",j,
2118  r->typ[j].data.dp.start, r->typ[j].data.dp.end,r->N);
2119  }
2120  }
2121  }
2122 
2123  assume(r != NULL);
2124  assume(r->cf != NULL);
2125 
2126  if (nCoeff_is_algExt(r->cf))
2127  {
2128  assume(r->cf->extRing != NULL);
2129  assume(r->cf->extRing->qideal != NULL);
2130  omCheckAddr(r->cf->extRing->qideal->m[0]);
2131  }
2132 
2133  //assume(r->cf!=NULL);
2134 
2135  return TRUE;
2136 }
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:934
#define omCheckAddr(addr)
Definition: omAllocDecl.h:328
#define omCheckAddrSize(addr, size)
Definition: omAllocDecl.h:327
#define omcheckAddrSize(addr, size)
Definition: omAllocDecl.h:329
@ ro_cp
Definition: ring.h:58
@ ro_wp_neg
Definition: ring.h:56
@ ro_wp
Definition: ring.h:53

◆ rDebugPrint()

void rDebugPrint ( const ring  r)

Definition at line 4072 of file ring.cc.

4073 {
4074  if (r==NULL)
4075  {
4076  PrintS("NULL ?\n");
4077  return;
4078  }
4079  // corresponds to ro_typ from ring.h:
4080  const char *TYP[]={"ro_dp","ro_wp","ro_am","ro_wp64","ro_wp_neg","ro_cp",
4081  "ro_syzcomp", "ro_syz", "ro_isTemp", "ro_is", "ro_none"};
4082  int i,j;
4083 
4084  Print("ExpL_Size:%d ",r->ExpL_Size);
4085  Print("CmpL_Size:%d ",r->CmpL_Size);
4086  Print("VarL_Size:%d\n",r->VarL_Size);
4087  Print("bitmask=0x%lx (expbound=%ld) \n",r->bitmask, r->bitmask);
4088  Print("divmask=%lx\n", r->divmask);
4089  Print("BitsPerExp=%d ExpPerLong=%d at L[%d]\n", r->BitsPerExp, r->ExpPerLong, r->VarL_Offset[0]);
4090 
4091  Print("VarL_LowIndex: %d\n", r->VarL_LowIndex);
4092  PrintS("VarL_Offset:\n");
4093  if (r->VarL_Offset==NULL) PrintS(" NULL");
4094  else
4095  for(j = 0; j < r->VarL_Size; j++)
4096  Print(" VarL_Offset[%d]: %d ", j, r->VarL_Offset[j]);
4097  PrintLn();
4098 
4099 
4100  PrintS("VarOffset:\n");
4101  if (r->VarOffset==NULL) PrintS(" NULL\n");
4102  else
4103  for(j=0;j<=r->N;j++)
4104  Print(" v%d at e-pos %d, bit %d\n",
4105  j,r->VarOffset[j] & 0xffffff, r->VarOffset[j] >>24);
4106  PrintS("ordsgn:\n");
4107  for(j=0;j<r->CmpL_Size;j++)
4108  Print(" ordsgn %ld at pos %d\n",r->ordsgn[j],j);
4109  Print("OrdSgn:%d\n",r->OrdSgn);
4110  PrintS("ordrec:\n");
4111  for(j=0;j<r->OrdSize;j++)
4112  {
4113  Print(" typ %s", TYP[r->typ[j].ord_typ]);
4114  if (r->typ[j].ord_typ==ro_syz)
4115  {
4116  const short place = r->typ[j].data.syz.place;
4117  const int limit = r->typ[j].data.syz.limit;
4118  const int curr_index = r->typ[j].data.syz.curr_index;
4119  const int* syz_index = r->typ[j].data.syz.syz_index;
4120 
4121  Print(" limit %d (place: %d, curr_index: %d), syz_index: ", limit, place, curr_index);
4122 
4123  if( syz_index == NULL )
4124  PrintS("(NULL)");
4125  else
4126  {
4127  PrintS("{");
4128  for( i=0; i <= limit; i++ )
4129  Print("%d ", syz_index[i]);
4130  PrintS("}");
4131  }
4132 
4133  }
4134  else if (r->typ[j].ord_typ==ro_isTemp)
4135  {
4136  Print(" start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
4137 
4138  }
4139  else if (r->typ[j].ord_typ==ro_is)
4140  {
4141  Print(" start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
4142 
4143 // 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]);
4144 
4145  Print(" limit %d",r->typ[j].data.is.limit);
4146 #ifndef SING_NDEBUG
4147  //PrintS(" F: ");idShow(r->typ[j].data.is.F, r, r, 1);
4148 #endif
4149 
4150  PrintLn();
4151  }
4152  else if (r->typ[j].ord_typ==ro_am)
4153  {
4154  Print(" place %d",r->typ[j].data.am.place);
4155  Print(" start %d",r->typ[j].data.am.start);
4156  Print(" end %d",r->typ[j].data.am.end);
4157  Print(" len_gen %d",r->typ[j].data.am.len_gen);
4158  PrintS(" w:");
4159  int l=0;
4160  for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
4161  Print(" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
4162  l=r->typ[j].data.am.end+1;
4163  int ll=r->typ[j].data.am.weights[l-r->typ[j].data.am.start];
4164  PrintS(" m:");
4165  for(int lll=l+1;lll<l+ll+1;lll++)
4166  Print(" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
4167  }
4168  else
4169  {
4170  Print(" place %d",r->typ[j].data.dp.place);
4171 
4172  if (r->typ[j].ord_typ!=ro_syzcomp && r->typ[j].ord_typ!=ro_syz)
4173  {
4174  Print(" start %d",r->typ[j].data.dp.start);
4175  Print(" end %d",r->typ[j].data.dp.end);
4176  if ((r->typ[j].ord_typ==ro_wp)
4177  || (r->typ[j].ord_typ==ro_wp_neg))
4178  {
4179  PrintS(" w:");
4180  for(int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;l++)
4181  Print(" %d",r->typ[j].data.wp.weights[l-r->typ[j].data.wp.start]);
4182  }
4183  else if (r->typ[j].ord_typ==ro_wp64)
4184  {
4185  PrintS(" w64:");
4186  int l;
4187  for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
4188  Print(" %ld",(long)(((int64*)r->typ[j].data.wp64.weights64)+l-r->typ[j].data.wp64.start));
4189  }
4190  }
4191  }
4192  PrintLn();
4193  }
4194  Print("pOrdIndex:%d pCompIndex:%d\n", r->pOrdIndex, r->pCompIndex);
4195  Print("OrdSize:%d\n",r->OrdSize);
4196  PrintS("--------------------\n");
4197  for(j=0;j<r->ExpL_Size;j++)
4198  {
4199  Print("L[%d]: ",j);
4200  if (j< r->CmpL_Size)
4201  Print("ordsgn %ld ", r->ordsgn[j]);
4202  else
4203  PrintS("no comp ");
4204  i=1;
4205  for(;i<=r->N;i++)
4206  {
4207  if( (r->VarOffset[i] & 0xffffff) == j )
4208  { Print("v%d at e[%d], bit %d; ", i,r->VarOffset[i] & 0xffffff,
4209  r->VarOffset[i] >>24 ); }
4210  }
4211  if( r->pCompIndex==j ) PrintS("v0; ");
4212  for(i=0;i<r->OrdSize;i++)
4213  {
4214  if (r->typ[i].data.dp.place == j)
4215  {
4216  Print("ordrec:%s (start:%d, end:%d) ",TYP[r->typ[i].ord_typ],
4217  r->typ[i].data.dp.start, r->typ[i].data.dp.end);
4218  }
4219  }
4220 
4221  if (j==r->pOrdIndex)
4222  PrintS("pOrdIndex\n");
4223  else
4224  PrintLn();
4225  }
4226  Print("LexOrder:%d, MixedOrder:%d\n",r->LexOrder, r->MixedOrder);
4227 
4228  Print("NegWeightL_Size: %d, NegWeightL_Offset: ", r->NegWeightL_Size);
4229  if (r->NegWeightL_Offset==NULL) PrintS(" NULL");
4230  else
4231  for(j = 0; j < r->NegWeightL_Size; j++)
4232  Print(" [%d]: %d ", j, r->NegWeightL_Offset[j]);
4233  PrintLn();
4234 
4235  // p_Procs stuff
4236  p_Procs_s proc_names;
4237  const char* field;
4238  const char* length;
4239  const char* ord;
4240  p_Debug_GetProcNames(r, &proc_names); // changes p_Procs!!!
4241  p_Debug_GetSpecNames(r, field, length, ord);
4242 
4243  Print("p_Spec : %s, %s, %s\n", field, length, ord);
4244  PrintS("p_Procs :\n");
4245  for (i=0; i<(int) (sizeof(p_Procs_s)/sizeof(void*)); i++)
4246  {
4247  Print(" %s,\n", ((char**) &proc_names)[i]);
4248  }
4249 
4250  {
4251  PrintLn();
4252  PrintS("pFDeg : ");
4253 #define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
4254  pFDeg_CASE(p_Totaldegree); else
4256  pFDeg_CASE(p_WTotaldegree); else
4257  pFDeg_CASE(p_Deg); else
4258 #undef pFDeg_CASE
4259  Print("(%p)", r->pFDeg); // default case
4260 
4261  PrintLn();
4262  Print("pLDeg : (%p)", r->pLDeg);
4263  PrintLn();
4264  }
4265  PrintS("pSetm:");
4266  void p_Setm_Dummy(poly p, const ring r);
4267  void p_Setm_TotalDegree(poly p, const ring r);
4268  void p_Setm_WFirstTotalDegree(poly p, const ring r);
4269  void p_Setm_General(poly p, const ring r);
4270  if (r->p_Setm==p_Setm_General) PrintS("p_Setm_General\n");
4271  else if (r->p_Setm==p_Setm_Dummy) PrintS("p_Setm_Dummy\n");
4272  else if (r->p_Setm==p_Setm_TotalDegree) PrintS("p_Setm_Totaldegree\n");
4273  else if (r->p_Setm==p_Setm_WFirstTotalDegree) PrintS("p_Setm_WFirstTotalDegree\n");
4274  else Print("%p\n",r->p_Setm);
4275 }
void p_Debug_GetProcNames(const ring r, p_Procs_s *p_Procs)
Definition: p_Procs_Set.h:232
void p_Debug_GetSpecNames(const ring r, const char *&field, const char *&length, const char *&ord)
Definition: p_Procs_Set.h:221
void p_Setm_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:549
long p_WFirstTotalDegree(poly p, const ring r)
Definition: p_polys.cc:591
void p_Setm_Dummy(poly p, const ring r)
Definition: p_polys.cc:536
void p_Setm_TotalDegree(poly p, const ring r)
Definition: p_polys.cc:542
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:582
#define pFDeg_CASE(A)
@ ro_wp64
Definition: ring.h:55
@ ro_am
Definition: ring.h:54

◆ rDefault() [1/4]

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

Definition at line 138 of file ring.cc.

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

◆ rDefault() [2/4]

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

Definition at line 102 of file ring.cc.

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

◆ rDefault() [3/4]

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

Definition at line 155 of file ring.cc.

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

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

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

◆ rDelete()

void rDelete ( ring  r)

unconditionally deletes fields in r

Definition at line 449 of file ring.cc.

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

◆ rEnvelope()

ring rEnvelope ( ring  R)

Definition at line 5640 of file ring.cc.

5643 {
5644  ring Ropp = rOpposite(R);
5645  ring Renv = NULL;
5646  int stat = rSum(R, Ropp, Renv); /* takes care of qideals */
5647  if ( stat <=0 )
5648  WarnS("Error in rEnvelope at rSum");
5649  rTest(Renv);
5650  return Renv;
5651 }
int rSum(ring r1, ring r2, ring &sum)
Definition: ring.cc:1344
ring rOpposite(ring src)
Definition: ring.cc:5250

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

1661 {
1662  if (r1 == r2) return TRUE;
1663  if (r1 == NULL || r2 == NULL) return FALSE;
1664  if (r1->cf!=r2->cf) return FALSE;
1665  if (rVar(r1)!=rVar(r2)) return FALSE;
1666  if (r1->bitmask!=r2->bitmask) return FALSE;
1667  #ifdef HAVE_SHIFTBBA
1668  if (r1->isLPring!=r2->isLPring) return FALSE;
1669  if (r1->LPncGenCount!=r2->LPncGenCount) return FALSE;
1670  #endif
1671 
1672  if( !rSamePolyRep(r1, r2) )
1673  return FALSE;
1674 
1675  int i/*, j*/;
1676 
1677  for (i=0; i<rVar(r1); i++)
1678  {
1679  if ((r1->names[i] != NULL) && (r2->names[i] != NULL))
1680  {
1681  if (strcmp(r1->names[i], r2->names[i])) return FALSE;
1682  }
1683  else if ((r1->names[i] != NULL) ^ (r2->names[i] != NULL))
1684  {
1685  return FALSE;
1686  }
1687  }
1688 
1689  if (qr)
1690  {
1691  if (r1->qideal != NULL)
1692  {
1693  ideal id1 = r1->qideal, id2 = r2->qideal;
1694  int i, n;
1695  poly *m1, *m2;
1696 
1697  if (id2 == NULL) return FALSE;
1698  if ((n = IDELEMS(id1)) != IDELEMS(id2)) return FALSE;
1699 
1700  {
1701  m1 = id1->m;
1702  m2 = id2->m;
1703  for (i=0; i<n; i++)
1704  if (! p_EqualPolys(m1[i],m2[i], r1, r2)) return FALSE;
1705  }
1706  }
1707  else if (r2->qideal != NULL) return FALSE;
1708  }
1709 
1710  return TRUE;
1711 }
Definition: qr.h:46
BOOLEAN p_EqualPolys(poly p1, poly p2, const ring r)
Definition: p_polys.cc:4540
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:1713
#define IDELEMS(i)
Definition: simpleideals.h:23

◆ rGetDivMask()

static unsigned long rGetDivMask ( int  bits)
static

get r->divmask depending on bits per exponent

Definition at line 4058 of file ring.cc.

4059 {
4060  unsigned long divmask = 1;
4061  int i = bits;
4062 
4063  while (i < BIT_SIZEOF_LONG)
4064  {
4065  divmask |= (((unsigned long) 1) << (unsigned long) i);
4066  i += bits;
4067  }
4068  return divmask;
4069 }

◆ rGetExpSize() [1/2]

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

Definition at line 2510 of file ring.cc.

2511 {
2512  if (bitmask == 0)
2513  {
2514  bits=16; bitmask=0xffff;
2515  }
2516  else if (bitmask <= 1L)
2517  {
2518  bits=1; bitmask = 1L;
2519  }
2520  else if (bitmask <= 3L)
2521  {
2522  bits=2; bitmask = 3L;
2523  }
2524  else if (bitmask <= 7L)
2525  {
2526  bits=3; bitmask=7L;
2527  }
2528  else if (bitmask <= 0xfL)
2529  {
2530  bits=4; bitmask=0xfL;
2531  }
2532  else if (bitmask <= 0x1fL)
2533  {
2534  bits=5; bitmask=0x1fL;
2535  }
2536  else if (bitmask <= 0x3fL)
2537  {
2538  bits=6; bitmask=0x3fL;
2539  }
2540 #if SIZEOF_LONG == 8
2541  else if (bitmask <= 0x7fL)
2542  {
2543  bits=7; bitmask=0x7fL; /* 64 bit longs only */
2544  }
2545 #endif
2546  else if (bitmask <= 0xffL)
2547  {
2548  bits=8; bitmask=0xffL;
2549  }
2550 #if SIZEOF_LONG == 8
2551  else if (bitmask <= 0x1ffL)
2552  {
2553  bits=9; bitmask=0x1ffL; /* 64 bit longs only */
2554  }
2555 #endif
2556  else if (bitmask <= 0x3ffL)
2557  {
2558  bits=10; bitmask=0x3ffL;
2559  }
2560 #if SIZEOF_LONG == 8
2561  else if (bitmask <= 0xfffL)
2562  {
2563  bits=12; bitmask=0xfff; /* 64 bit longs only */
2564  }
2565 #endif
2566  else if (bitmask <= 0xffffL)
2567  {
2568  bits=16; bitmask=0xffffL;
2569  }
2570 #if SIZEOF_LONG == 8
2571  else if (bitmask <= 0xfffffL)
2572  {
2573  bits=20; bitmask=0xfffffL; /* 64 bit longs only */
2574  }
2575  else if (bitmask <= 0xffffffffL)
2576  {
2577  bits=32; bitmask=0xffffffffL;
2578  }
2579  else if (bitmask <= 0x7fffffffffffffffL)
2580  {
2581  bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
2582  }
2583  else
2584  {
2585  bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
2586  }
2587 #else
2588  else if (bitmask <= 0x7fffffff)
2589  {
2590  bits=31; bitmask=0x7fffffff; /* for overflow tests*/
2591  }
2592  else
2593  {
2594  bits=31; bitmask=0x7fffffffL; /* for overflow tests*/
2595  }
2596 #endif
2597  return bitmask;
2598 }

◆ rGetExpSize() [2/2]

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

Definition at line 2603 of file ring.cc.

2604 {
2605 #if SIZEOF_LONG == 8
2606  if (N<4) N=4;
2607 #else
2608  if (N<2) N=2;
2609 #endif
2610  bitmask =rGetExpSize(bitmask, bits);
2611  int vars_per_long=BIT_SIZEOF_LONG/bits;
2612  int bits1;
2613  loop
2614  {
2615  if (bits == BIT_SIZEOF_LONG-1)
2616  {
2617  bits = BIT_SIZEOF_LONG - 1;
2618  return LONG_MAX;
2619  }
2620  unsigned long bitmask1 =rGetExpSize(bitmask+1, bits1);
2621  int vars_per_long1=BIT_SIZEOF_LONG/bits1;
2622  if ((((N+vars_per_long-1)/vars_per_long) ==
2623  ((N+vars_per_long1-1)/vars_per_long1)))
2624  {
2625  vars_per_long=vars_per_long1;
2626  bits=bits1;
2627  bitmask=bitmask1;
2628  }
2629  else
2630  {
2631  return bitmask; /* and bits */
2632  }
2633  }
2634 }
#define loop
Definition: structs.h:80

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

4948 {
4949  // Put the reference set F into the ring -ordering -recor
4950 #if MYTEST
4951  Print("rIsIS(p: %d)\nF:", p);
4952  PrintLn();
4953 #endif
4954 
4955  if (r->typ==NULL)
4956  {
4957 // dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
4958  return -1;
4959  }
4960 
4961  int j = p; // Which IS record to use...
4962  for( int pos = 0; pos < r->OrdSize; pos++ )
4963  if( r->typ[pos].ord_typ == ro_is)
4964  if( j-- == 0 )
4965  return pos;
4966 
4967  return -1;
4968 }

◆ rGetMaxSyzComp()

int rGetMaxSyzComp ( int  i,
const ring  r 
)

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

Definition at line 5105 of file ring.cc.

5106 {
5107  if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz) &&
5108  r->typ[0].data.syz.limit > 0 && i > 0)
5109  {
5110  assume(i <= r->typ[0].data.syz.limit);
5111  int j;
5112  for (j=0; j<r->typ[0].data.syz.limit; j++)
5113  {
5114  if (r->typ[0].data.syz.syz_index[j] == i &&
5115  r->typ[0].data.syz.syz_index[j+1] != i)
5116  {
5117  assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5118  return j;
5119  }
5120  }
5121  return r->typ[0].data.syz.limit;
5122  }
5123  else
5124  {
5125  #ifndef SING_NDEBUG
5126  WarnS("rGetMaxSyzComp: order c");
5127  #endif
5128  return 0;
5129  }
5130 }

◆ rGetOrderType()

rOrderType_t rGetOrderType ( ring  r)

Definition at line 1754 of file ring.cc.

1755 {
1756  // check for simple ordering
1757  if (rHasSimpleOrder(r))
1758  {
1759  if ((r->order[1] == ringorder_c)
1760  || (r->order[1] == ringorder_C))
1761  {
1762  switch(r->order[0])
1763  {
1764  case ringorder_dp:
1765  case ringorder_wp:
1766  case ringorder_ds:
1767  case ringorder_ws:
1768  case ringorder_ls:
1769  case ringorder_unspec:
1770  if (r->order[1] == ringorder_C
1771  || r->order[0] == ringorder_unspec)
1772  return rOrderType_ExpComp;
1773  return rOrderType_Exp;
1774 
1775  default:
1776  assume(r->order[0] == ringorder_lp ||
1777  r->order[0] == ringorder_rs ||
1778  r->order[0] == ringorder_Dp ||
1779  r->order[0] == ringorder_Wp ||
1780  r->order[0] == ringorder_Ds ||
1781  r->order[0] == ringorder_Ws);
1782 
1783  if (r->order[1] == ringorder_c) return rOrderType_ExpComp;
1784  return rOrderType_Exp;
1785  }
1786  }
1787  else
1788  {
1789  assume((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C));
1790  return rOrderType_CompExp;
1791  }
1792  }
1793  else
1794  return rOrderType_General;
1795 }
BOOLEAN rHasSimpleOrder(const ring r)
Definition: ring.cc:1801
@ rOrderType_CompExp
simple ordering, component has priority
Definition: ring.h:100
@ rOrderType_Exp
simple ordering, exponent vector has priority component is compatible with exp-vector order
Definition: ring.h:103
@ rOrderType_General
non-simple ordering as specified by currRing
Definition: ring.h:99
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
Definition: ring.h:101

◆ rGetSComps()

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

Definition at line 4402 of file ring.cc.

4403 {
4404 #ifdef PDEBUG
4405  rDBGetSComps(currComponents, currShiftedComponents, length, r);
4406 #else
4407  rNGetSComps(currComponents, currShiftedComponents, r);
4408 #endif
4409 }
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition: ring.cc:4381

◆ rGetVar()

poly rGetVar ( const int  varIndex,
const ring  r 
)

Definition at line 5755 of file ring.cc.

5756 {
5757  poly p = p_ISet(1, r);
5758  p_SetExp(p, varIndex, 1, r);
5759  p_Setm(p, r);
5760  return p;
5761 }
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1292
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:488
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233

◆ rGetWeightVec()

int64* rGetWeightVec ( const ring  r)

Definition at line 5191 of file ring.cc.

5192 {
5193  assume(r!=NULL);
5194  assume(r->OrdSize>0);
5195  int i=0;
5196  while((r->typ[i].ord_typ!=ro_wp64) && (r->typ[i].ord_typ>0)) i++;
5197  assume(r->typ[i].ord_typ==ro_wp64);
5198  return (int64*)(r->typ[i].data.wp64.weights64);
5199 }

◆ rHas_c_Ordering()

BOOLEAN rHas_c_Ordering ( const ring  r)

Definition at line 1797 of file ring.cc.

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

◆ rHasSimpleLexOrder()

BOOLEAN rHasSimpleLexOrder ( const ring  r)

returns TRUE, if simple lp or ls ordering

Definition at line 1833 of file ring.cc.

1834 {
1835  return rHasSimpleOrder(r) &&
1836  (r->order[0] == ringorder_ls ||
1837  r->order[0] == ringorder_lp ||
1838  r->order[1] == ringorder_ls ||
1839  r->order[1] == ringorder_lp);
1840 }

◆ rHasSimpleOrder()

BOOLEAN rHasSimpleOrder ( const ring  r)

Definition at line 1801 of file ring.cc.

1802 {
1803  if (r->order[0] == ringorder_unspec) return TRUE;
1804  int blocks = rBlocks(r) - 1;
1805  assume(blocks >= 1);
1806  if (blocks == 1) return TRUE;
1807 
1808  int s = 0;
1809  while( (s < blocks) && (r->order[s] == ringorder_IS) && (r->order[blocks-1] == ringorder_IS) )
1810  {
1811  s++;
1812  blocks--;
1813  }
1814 
1815  if ((blocks - s) > 2) return FALSE;
1816 
1817  assume( blocks == s + 2 );
1818 
1819  if (
1820  (r->order[s] != ringorder_c)
1821  && (r->order[s] != ringorder_C)
1822  && (r->order[s+1] != ringorder_c)
1823  && (r->order[s+1] != ringorder_C)
1824  )
1825  return FALSE;
1826  if ((r->order[s+1] == ringorder_M)
1827  || (r->order[s] == ringorder_M))
1828  return FALSE;
1829  return TRUE;
1830 }

◆ rHasSimpleOrderAA()

BOOLEAN rHasSimpleOrderAA ( ring  r)

Definition at line 1876 of file ring.cc.

1877 {
1878  if (r->order[0] == ringorder_unspec) return TRUE;
1879  int blocks = rBlocks(r) - 1;
1880  assume(blocks >= 1);
1881  if (blocks == 1) return TRUE;
1882 
1883  int s = 0;
1884  while( (s < blocks) && (r->order[s] == ringorder_IS) && (r->order[blocks-1] == ringorder_IS) )
1885  {
1886  s++;
1887  blocks--;
1888  }
1889 
1890  if ((blocks - s) > 3) return FALSE;
1891 
1892 // if ((blocks > 3) || (blocks < 2)) return FALSE;
1893  if ((blocks - s) == 3)
1894  {
1895  return (((r->order[s] == ringorder_aa) && (r->order[s+1] != ringorder_M) &&
1896  ((r->order[s+2] == ringorder_c) || (r->order[s+2] == ringorder_C))) ||
1897  (((r->order[s] == ringorder_c) || (r->order[s] == ringorder_C)) &&
1898  (r->order[s+1] == ringorder_aa) && (r->order[s+2] != ringorder_M)));
1899  }
1900  else
1901  {
1902  return ((r->order[s] == ringorder_aa) && (r->order[s+1] != ringorder_M));
1903  }
1904 }

◆ rIsPolyVar()

BOOLEAN rIsPolyVar ( int  v,
const ring  r 
)

returns TRUE if var(i) belongs to p-block

Definition at line 1950 of file ring.cc.

1951 {
1952  int i=0;
1953  while(r->order[i]!=0)
1954  {
1955  if((r->block0[i]<=v)
1956  && (r->block1[i]>=v))
1957  {
1958  switch(r->order[i])
1959  {
1960  case ringorder_a:
1961  return (r->wvhdl[i][v-r->block0[i]]>0);
1962  case ringorder_M:
1963  return 2; /*don't know*/
1964  case ringorder_a64: /* assume: all weight are non-negative!*/
1965  case ringorder_lp:
1966  case ringorder_rs:
1967  case ringorder_dp:
1968  case ringorder_Dp:
1969  case ringorder_wp:
1970  case ringorder_Wp:
1971  return TRUE;
1972  case ringorder_ls:
1973  case ringorder_ds:
1974  case ringorder_Ds:
1975  case ringorder_ws:
1976  case ringorder_Ws:
1977  return FALSE;
1978  default:
1979  break;
1980  }
1981  }
1982  i++;
1983  }
1984  return 3; /* could not find var v*/
1985 }

◆ rKillModified_Wp_Ring()

void rKillModified_Wp_Ring ( ring  r)

Definition at line 3014 of file ring.cc.

3015 {
3016  rUnComplete(r);
3017  omFree(r->order);
3018  omFree(r->block0);
3019  omFree(r->block1);
3020  omFree(r->wvhdl[0]);
3021  omFree(r->wvhdl);
3023 }

◆ rKillModifiedRing()

void rKillModifiedRing ( ring  r)

Definition at line 3004 of file ring.cc.

3005 {
3006  rUnComplete(r);
3007  omFree(r->order);
3008  omFree(r->block0);
3009  omFree(r->block1);
3010  omFree(r->wvhdl);
3012 }

◆ rMinusVar()

ring rMinusVar ( const ring  r,
char *  v 
)

undo rPlusVar

Definition at line 5868 of file ring.cc.

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

◆ rModify_a_to_A()

void rModify_a_to_A ( ring  r)

Definition at line 5732 of file ring.cc.

5735 {
5736  int i=0;
5737  int j;
5738  while(r->order[i]!=0)
5739  {
5740  if (r->order[i]==ringorder_a)
5741  {
5742  r->order[i]=ringorder_a64;
5743  int *w=r->wvhdl[i];
5744  int64 *w64=(int64 *)omAlloc((r->block1[i]-r->block0[i]+1)*sizeof(int64));
5745  for(j=r->block1[i]-r->block0[i];j>=0;j--)
5746  w64[j]=(int64)w[j];
5747  r->wvhdl[i]=(int*)w64;
5748  omFreeSize(w,(r->block1[i]-r->block0[i]+1)*sizeof(int));
5749  }
5750  i++;
5751  }
5752 }
const CanonicalForm & w
Definition: facAbsFact.cc:51

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

2646 {
2647  assume (r != NULL );
2648  assume (exp_limit > 1);
2649  BOOLEAN omitted_degree = FALSE;
2650 
2651  int bits;
2652  exp_limit=rGetExpSize(exp_limit, bits, r->N);
2653  BOOLEAN need_other_ring = (exp_limit != r->bitmask);
2654 
2655  int iNeedInducedOrderingSetup = 0; ///< How many induced ordering block do we have?
2656 
2657  int nblocks=rBlocks(r);
2658  rRingOrder_t *order=(rRingOrder_t*)omAlloc0((nblocks+1)*sizeof(rRingOrder_t));
2659  int *block0=(int*)omAlloc0((nblocks+1)*sizeof(int));
2660  int *block1=(int*)omAlloc0((nblocks+1)*sizeof(int));
2661  int **wvhdl=(int**)omAlloc0((nblocks+1)*sizeof(int *));
2662 
2663  int i=0;
2664  int j=0; /* i index in r, j index in res */
2665 
2666  for( rRingOrder_t r_ord=r->order[i]; (r_ord != (rRingOrder_t)0) && (i < nblocks); j++, r_ord=r->order[++i])
2667  {
2668  BOOLEAN copy_block_index=TRUE;
2669 
2670  if (r->block0[i]==r->block1[i])
2671  {
2672  switch(r_ord)
2673  {
2674  case ringorder_wp:
2675  case ringorder_dp:
2676  case ringorder_Wp:
2677  case ringorder_Dp:
2678  r_ord=ringorder_lp;
2679  break;
2680  case ringorder_Ws:
2681  case ringorder_Ds:
2682  case ringorder_ws:
2683  case ringorder_ds:
2684  r_ord=ringorder_ls;
2685  break;
2686  default:
2687  break;
2688  }
2689  }
2690  switch(r_ord)
2691  {
2692  case ringorder_S:
2693  {
2694 #ifndef SING_NDEBUG
2695  Warn("Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
2696 #endif
2697  order[j]=r_ord; /*r->order[i];*/
2698  break;
2699  }
2700  case ringorder_C:
2701  case ringorder_c:
2702  if (!try_omit_comp)
2703  {
2704  order[j]=r_ord; /*r->order[i]*/;
2705  }
2706  else
2707  {
2708  j--;
2709  need_other_ring=TRUE;
2710  try_omit_comp=FALSE;
2711  copy_block_index=FALSE;
2712  }
2713  break;
2714  case ringorder_wp:
2715  case ringorder_dp:
2716  case ringorder_ws:
2717  case ringorder_ds:
2718  if(!omit_degree)
2719  {
2720  order[j]=r_ord; /*r->order[i]*/;
2721  }
2722  else
2723  {
2724  order[j]=ringorder_rs;
2725  need_other_ring=TRUE;
2726  omit_degree=FALSE;
2727  omitted_degree = TRUE;
2728  }
2729  break;
2730  case ringorder_Wp:
2731  case ringorder_Dp:
2732  case ringorder_Ws:
2733  case ringorder_Ds:
2734  if(!omit_degree)
2735  {
2736  order[j]=r_ord; /*r->order[i];*/
2737  }
2738  else
2739  {
2740  order[j]=ringorder_lp;
2741  need_other_ring=TRUE;
2742  omit_degree=FALSE;
2743  omitted_degree = TRUE;
2744  }
2745  break;
2746  case ringorder_IS:
2747  {
2748  if (try_omit_comp)
2749  {
2750  // tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_IS)", i, r_ord
2751  try_omit_comp = FALSE;
2752  }
2753  order[j]=r_ord; /*r->order[i];*/
2754  iNeedInducedOrderingSetup++;
2755  break;
2756  }
2757  case ringorder_s:
2758  {
2759  assume((i == 0) && (j == 0));
2760  if (try_omit_comp)
2761  {
2762  // tried, but cannot omit component due to the ordering block [%d]: %d (ringorder_s)", i, r_ord
2763  try_omit_comp = FALSE;
2764  }
2765  order[j]=r_ord; /*r->order[i];*/
2766  break;
2767  }
2768  default:
2769  order[j]=r_ord; /*r->order[i];*/
2770  break;
2771  }
2772  if (copy_block_index)
2773  {
2774  block0[j]=r->block0[i];
2775  block1[j]=r->block1[i];
2776  wvhdl[j]=r->wvhdl[i];
2777  }
2778 
2779  // order[j]=ringorder_no; // done by omAlloc0
2780  }
2781  if(!need_other_ring)
2782  {
2783  omFreeSize(order,(nblocks+1)*sizeof(rRingOrder_t));
2784  omFreeSize(block0,(nblocks+1)*sizeof(int));
2785  omFreeSize(block1,(nblocks+1)*sizeof(int));
2786  omFreeSize(wvhdl,(nblocks+1)*sizeof(int *));
2787  return r;
2788  }
2789  ring res=(ring)omAlloc0Bin(sip_sring_bin);
2790  *res = *r;
2791 
2792 #ifdef HAVE_PLURAL
2793  res->GetNC() = NULL;
2794 #endif
2795 
2796  // res->qideal, res->idroot ???
2797  res->wvhdl=wvhdl;
2798  res->order=order;
2799  res->block0=block0;
2800  res->block1=block1;
2801  res->bitmask=exp_limit;
2802  res->wanted_maxExp=r->wanted_maxExp;
2803  //int tmpref=r->cf->ref0;
2804  rComplete(res, 1);
2805  //r->cf->ref=tmpref;
2806 
2807  // adjust res->pFDeg: if it was changed globally, then
2808  // it must also be changed for new ring
2809  if (r->pFDegOrig != res->pFDegOrig &&
2811  {
2812  // still might need adjustment for weighted orderings
2813  // and omit_degree
2814  res->firstwv = r->firstwv;
2815  res->firstBlockEnds = r->firstBlockEnds;
2816  res->pFDeg = res->pFDegOrig = p_WFirstTotalDegree;
2817  }
2818  if (omitted_degree)
2819  res->pLDeg = r->pLDegOrig;
2820 
2821  rOptimizeLDeg(res); // also sets res->pLDegOrig
2822 
2823  // set syzcomp
2824  if (res->typ != NULL)
2825  {
2826  if( res->typ[0].ord_typ == ro_syz) // "s" Always on [0] place!
2827  {
2828  res->typ[0] = r->typ[0]; // Copy struct!? + setup the same limit!
2829 
2830  if (r->typ[0].data.syz.limit > 0)
2831  {
2832  res->typ[0].data.syz.syz_index
2833  = (int*) omAlloc((r->typ[0].data.syz.limit +1)*sizeof(int));
2834  memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
2835  (r->typ[0].data.syz.limit +1)*sizeof(int));
2836  }
2837  }
2838 
2839  if( iNeedInducedOrderingSetup > 0 )
2840  {
2841  for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
2842  if( res->typ[i].ord_typ == ro_is ) // Search for suffixes!
2843  {
2844  ideal F = idrHeadR(r->typ[i].data.is.F, r, res); // Copy F from r into res!
2845  assume(
2847  F, // WILL BE COPIED!
2848  r->typ[i].data.is.limit,
2849  j++
2850  )
2851  );
2852  id_Delete(&F, res);
2853  iNeedInducedOrderingSetup--;
2854  }
2855  } // Process all induced Ordering blocks! ...
2856  }
2857  // the special case: homog (omit_degree) and 1 block rs: that is global:
2858  // it comes from dp
2859  res->OrdSgn=r->OrdSgn;
2860 
2861 
2862 #ifdef HAVE_PLURAL
2863  if (rIsPluralRing(r))
2864  {
2865  if ( nc_rComplete(r, res, false) ) // no qideal!
2866  {
2867 #ifndef SING_NDEBUG
2868  WarnS("error in nc_rComplete");
2869 #endif
2870  // cleanup?
2871 
2872 // rDelete(res);
2873 // return r;
2874 
2875  // just go on..
2876  }
2877 
2878  if( rIsSCA(r) )
2879  {
2880  if( !sca_Force(res, scaFirstAltVar(r), scaLastAltVar(r)) )
2881  WarnS("error in sca_Force!");
2882  }
2883  }
2884 #endif
2885 
2886  return res;
2887 }
#define Warn
Definition: emacs.cc:77
bool sca_Force(ring rGR, int b, int e)
Definition: sca.cc:1161
ideal idrHeadR(ideal id, ring r, ring dest_r)
Copy leading terms of id[i] via prHeeadR into dest_r.
Definition: prCopy.cc:155
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:4979
static void rOptimizeLDeg(ring r)
Definition: ring.cc:3100
BOOLEAN rOrd_is_WeightedDegree_Ordering(const ring r)
Definition: ring.cc:1941
static short scaLastAltVar(ring r)
Definition: sca.h:25
static short scaFirstAltVar(ring r)
Definition: sca.h:18

◆ rModifyRing_Simple()

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

Definition at line 2938 of file ring.cc.

2939 {
2940  simple=TRUE;
2941  if (!rHasSimpleOrder(r))
2942  {
2943  simple=FALSE; // sorting needed
2944  assume (r != NULL );
2945  assume (exp_limit > 1);
2946  int bits;
2947 
2948  exp_limit=rGetExpSize(exp_limit, bits, r->N);
2949 
2950  int nblocks=1+(ommit_comp!=0);
2951  rRingOrder_t *order=(rRingOrder_t*)omAlloc0((nblocks+1)*sizeof(rRingOrder_t));
2952  int *block0=(int*)omAlloc0((nblocks+1)*sizeof(int));
2953  int *block1=(int*)omAlloc0((nblocks+1)*sizeof(int));
2954  int **wvhdl=(int**)omAlloc0((nblocks+1)*sizeof(int *));
2955 
2956  order[0]=ringorder_lp;
2957  block0[0]=1;
2958  block1[0]=r->N;
2959  if (!ommit_comp)
2960  {
2961  order[1]=ringorder_C;
2962  }
2963  ring res=(ring)omAlloc0Bin(sip_sring_bin);
2964  *res = *r;
2965 #ifdef HAVE_PLURAL
2966  res->GetNC() = NULL;
2967 #endif
2968  // res->qideal, res->idroot ???
2969  res->wvhdl=wvhdl;
2970  res->order=order;
2971  res->block0=block0;
2972  res->block1=block1;
2973  res->bitmask=exp_limit;
2974  res->wanted_maxExp=r->wanted_maxExp;
2975  //int tmpref=r->cf->ref;
2976  rComplete(res, 1);
2977  //r->cf->ref=tmpref;
2978 
2979 #ifdef HAVE_PLURAL
2980  if (rIsPluralRing(r))
2981  {
2982  if ( nc_rComplete(r, res, false) ) // no qideal!
2983  {
2984 #ifndef SING_NDEBUG
2985  WarnS("error in nc_rComplete");
2986 #endif
2987  // cleanup?
2988 
2989 // rDelete(res);
2990 // return r;
2991 
2992  // just go on..
2993  }
2994  }
2995 #endif
2996 
2997  rOptimizeLDeg(res);
2998 
2999  return res;
3000  }
3001  return rModifyRing(r, ommit_degree, ommit_comp, exp_limit);
3002 }
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
Definition: ring.cc:2643

◆ rModifyRing_Wp()

ring rModifyRing_Wp ( ring  r,
int *  weights 
)

construct Wp, C ring

Definition at line 2890 of file ring.cc.

2891 {
2892  ring res=(ring)omAlloc0Bin(sip_sring_bin);
2893  *res = *r;
2894 #ifdef HAVE_PLURAL
2895  res->GetNC() = NULL;
2896 #endif
2897 
2898  /*weights: entries for 3 blocks: NULL*/
2899  res->wvhdl = (int **)omAlloc0(3 * sizeof(int *));
2900  /*order: Wp,C,0*/
2901  res->order = (rRingOrder_t *) omAlloc(3 * sizeof(rRingOrder_t *));
2902  res->block0 = (int *)omAlloc0(3 * sizeof(int *));
2903  res->block1 = (int *)omAlloc0(3 * sizeof(int *));
2904  /* ringorder Wp for the first block: var 1..r->N */
2905  res->order[0] = ringorder_Wp;
2906  res->block0[0] = 1;
2907  res->block1[0] = r->N;
2908  res->wvhdl[0] = weights;
2909  /* ringorder C for the second block: no vars */
2910  res->order[1] = ringorder_C;
2911  /* the last block: everything is 0 */
2912  res->order[2] = (rRingOrder_t)0;
2913 
2914  //int tmpref=r->cf->ref;
2915  rComplete(res, 1);
2916  //r->cf->ref=tmpref;
2917 #ifdef HAVE_PLURAL
2918  if (rIsPluralRing(r))
2919  {
2920  if ( nc_rComplete(r, res, false) ) // no qideal!
2921  {
2922 #ifndef SING_NDEBUG
2923  WarnS("error in nc_rComplete");
2924 #endif
2925  // cleanup?
2926 
2927 // rDelete(res);
2928 // return r;
2929 
2930  // just go on..
2931  }
2932  }
2933 #endif
2934  return res;
2935 }

◆ rNChangeSComps()

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

Definition at line 4355 of file ring.cc.

4356 {
4357  assume(r->typ[1].ord_typ == ro_syzcomp);
4358 
4359  r->typ[1].data.syzcomp.ShiftedComponents = currShiftedComponents;
4360  r->typ[1].data.syzcomp.Components = currComponents;
4361 }

◆ rNGetSComps()

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

Definition at line 4363 of file ring.cc.

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

◆ rO_Align()

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

Definition at line 2139 of file ring.cc.

2140 {
2141  // increment place to the next aligned one
2142  // (count as Exponent_t,align as longs)
2143  if (bitplace!=BITS_PER_LONG)
2144  {
2145  place++;
2146  bitplace=BITS_PER_LONG;
2147  }
2148 }

◆ rO_ISPrefix()

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

Definition at line 2401 of file ring.cc.

2403 {
2404  if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2405  rO_Align(place,bitplace);
2406  // since we add something afterwards - it's better to start with anew!?
2407 
2408  ord_struct.ord_typ = ro_isTemp;
2409  ord_struct.data.isTemp.start = place;
2410  ord_struct.data.isTemp.pVarOffset = (int *)omMemDup(v);
2411  ord_struct.data.isTemp.suffixpos = -1;
2412 
2413  // We will act as rO_Syz on our own!!!
2414  // Here we allocate an exponent as a level placeholder
2415  o[place]= -1;
2416  prev_ord=-1;
2417  place++;
2418 }
ro_typ ord_typ
Definition: ring.h:220
union sro_ord::@0 data

◆ 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 
)
static

Definition at line 2419 of file ring.cc.

2421 {
2422 
2423  // Let's find previous prefix:
2424  int typ_j = typ_i - 1;
2425  while(typ_j >= 0)
2426  {
2427  if( tmp_typ[typ_j].ord_typ == ro_isTemp)
2428  break;
2429  typ_j --;
2430  }
2431 
2432  assume( typ_j >= 0 );
2433 
2434  if( typ_j < 0 ) // Found NO prefix!!! :(
2435  return;
2436 
2437  assume( tmp_typ[typ_j].ord_typ == ro_isTemp );
2438 
2439  // Get saved state:
2440  const int start = tmp_typ[typ_j].data.isTemp.start;
2441  int *pVarOffset = tmp_typ[typ_j].data.isTemp.pVarOffset;
2442 
2443 /*
2444  // shift up all blocks
2445  while(typ_j < (typ_i-1))
2446  {
2447  tmp_typ[typ_j] = tmp_typ[typ_j+1];
2448  typ_j++;
2449  }
2450  typ_j = typ_i - 1; // No increment for typ_i
2451 */
2452  tmp_typ[typ_j].data.isTemp.suffixpos = typ_i;
2453 
2454  // Let's keep that dummy for now...
2455  typ_j = typ_i; // the typ to change!
2456  typ_i++; // Just for now...
2457 
2458 
2459  for( int i = 0; i <= N; i++ ) // Note [0] == component !!! No Skip?
2460  {
2461  // Was i-th variable allocated inbetween?
2462  if( v[i] != pVarOffset[i] )
2463  {
2464  pVarOffset[i] = v[i]; // Save for later...
2465  v[i] = -1; // Undo!
2466  assume( pVarOffset[i] != -1 );
2467  }
2468  else
2469  pVarOffset[i] = -1; // No change here...
2470  }
2471 
2472  if( pVarOffset[0] != -1 )
2473  pVarOffset[0] &= 0x0fff;
2474 
2475  sro_ord &ord_struct = tmp_typ[typ_j];
2476 
2477 
2478  ord_struct.ord_typ = ro_is;
2479  ord_struct.data.is.start = start;
2480  ord_struct.data.is.end = place;
2481  ord_struct.data.is.pVarOffset = pVarOffset;
2482 
2483 
2484  // What about component???
2485 // if( v[0] != -1 ) // There is a component already...???
2486 // if( o[ v[0] & 0x0fff ] == sgn )
2487 // {
2488 // pVarOffset[0] = -1; // NEVER USED Afterwards...
2489 // return;
2490 // }
2491 
2492 
2493  // Moreover: we need to allocate the module component (v[0]) here!
2494  if( v[0] == -1) // It's possible that there was module component v0 at the begining (before prefix)!
2495  {
2496  // Start with a whole long exponent
2497  if( bitplace != BITS_PER_LONG )
2498  rO_Align(place, bitplace);
2499 
2500  assume( bitplace == BITS_PER_LONG );
2501  bitplace -= BITS_PER_LONG;
2502  assume(bitplace == 0);
2503  v[0] = place | (bitplace << 24); // Never mind whether pVarOffset[0] > 0!!!
2504  o[place] = sgn; // Singnum for component ordering
2505  prev_ord = sgn;
2506  }
2507 }

◆ 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 
)
static

Definition at line 2284 of file ring.cc.

2286 {
2287  // a block of variables v_start..v_end with lex order, ordsgn 1
2288  int k;
2289  int incr=1;
2290  if(prev_ord==-1) rO_Align(place,bitplace);
2291 
2292  if (start>end)
2293  {
2294  incr=-1;
2295  }
2296  for(k=start;;k+=incr)
2297  {
2298  bitplace-=bits;
2299  if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
2300  o[place]=1;
2301  v[k]= place | (bitplace << 24);
2302  if (k==end) break;
2303  }
2304  prev_ord=1;
2305  if (opt_var!= -1)
2306  {
2307  assume((opt_var == end+1) ||(opt_var == end-1));
2308  if((opt_var != end+1) &&(opt_var != end-1)) WarnS("hier-2");
2309  int save_bitplace=bitplace;
2310  bitplace-=bits;
2311  if (bitplace < 0)
2312  {
2313  bitplace=save_bitplace;
2314  return;
2315  }
2316  // there is enough space for the optional var
2317  v[opt_var]=place | (bitplace << 24);
2318  }
2319 }

◆ 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 
)
static

Definition at line 2321 of file ring.cc.

2323 {
2324  // a block of variables v_start..v_end with lex order, ordsgn -1
2325  int k;
2326  int incr=1;
2327  if(prev_ord==1) rO_Align(place,bitplace);
2328 
2329  if (start>end)
2330  {
2331  incr=-1;
2332  }
2333  for(k=start;;k+=incr)
2334  {
2335  bitplace-=bits;
2336  if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
2337  o[place]=-1;
2338  v[k]=place | (bitplace << 24);
2339  if (k==end) break;
2340  }
2341  prev_ord=-1;
2342 // #if 0
2343  if (opt_var!= -1)
2344  {
2345  assume((opt_var == end+1) ||(opt_var == end-1));
2346  if((opt_var != end+1) &&(opt_var != end-1)) WarnS("hier-1");
2347  int save_bitplace=bitplace;
2348  bitplace-=bits;
2349  if (bitplace < 0)
2350  {
2351  bitplace=save_bitplace;
2352  return;
2353  }
2354  // there is enough space for the optional var
2355  v[opt_var]=place | (bitplace << 24);
2356  }
2357 // #endif
2358 }

◆ rO_Syz()

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

Definition at line 2375 of file ring.cc.

2377 {
2378  // ordering is derived from component number
2379  // let's reserve one Exponent_t for it
2380  if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2381  rO_Align(place,bitplace);
2382  ord_struct.ord_typ=ro_syz;
2383  ord_struct.data.syz.place=place;
2384  ord_struct.data.syz.limit=syz_comp;
2385  if (syz_comp>0)
2386  ord_struct.data.syz.syz_index = (int*) omAlloc0((syz_comp+1)*sizeof(int));
2387  else
2388  ord_struct.data.syz.syz_index = NULL;
2389  ord_struct.data.syz.curr_index = 1;
2390  o[place]= -1;
2391  prev_ord=-1;
2392  place++;
2393 }

◆ rO_Syzcomp()

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

Definition at line 2360 of file ring.cc.

2362 {
2363  // ordering is derived from component number
2364  rO_Align(place,bitplace);
2365  ord_struct.ord_typ=ro_syzcomp;
2366  ord_struct.data.syzcomp.place=place;
2367  ord_struct.data.syzcomp.Components=NULL;
2368  ord_struct.data.syzcomp.ShiftedComponents=NULL;
2369  o[place]=1;
2370  prev_ord=1;
2371  place++;
2372  rO_Align(place,bitplace);
2373 }

◆ rO_TDegree()

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

Definition at line 2150 of file ring.cc.

2152 {
2153  // degree (aligned) of variables v_start..v_end, ordsgn 1
2154  rO_Align(place,bitplace);
2155  ord_struct.ord_typ=ro_dp;
2156  ord_struct.data.dp.start=start;
2157  ord_struct.data.dp.end=end;
2158  ord_struct.data.dp.place=place;
2159  o[place]=1;
2160  place++;
2161  rO_Align(place,bitplace);
2162 }

◆ rO_TDegree_neg()

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

Definition at line 2164 of file ring.cc.

2166 {
2167  // degree (aligned) of variables v_start..v_end, ordsgn -1
2168  rO_Align(place,bitplace);
2169  ord_struct.ord_typ=ro_dp;
2170  ord_struct.data.dp.start=start;
2171  ord_struct.data.dp.end=end;
2172  ord_struct.data.dp.place=place;
2173  o[place]=-1;
2174  place++;
2175  rO_Align(place,bitplace);
2176 }

◆ rO_WDegree()

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

Definition at line 2178 of file ring.cc.

2180 {
2181  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2182  while((start<end) && (weights[0]==0)) { start++; weights++; }
2183  while((start<end) && (weights[end-start]==0)) { end--; }
2184  int i;
2185  int pure_tdeg=1;
2186  for(i=start;i<=end;i++)
2187  {
2188  if(weights[i-start]!=1)
2189  {
2190  pure_tdeg=0;
2191  break;
2192  }
2193  }
2194  if (pure_tdeg)
2195  {
2196  rO_TDegree(place,bitplace,start,end,o,ord_struct);
2197  return;
2198  }
2199  rO_Align(place,bitplace);
2200  ord_struct.ord_typ=ro_wp;
2201  ord_struct.data.wp.start=start;
2202  ord_struct.data.wp.end=end;
2203  ord_struct.data.wp.place=place;
2204  ord_struct.data.wp.weights=weights;
2205  o[place]=1;
2206  place++;
2207  rO_Align(place,bitplace);
2208  for(i=start;i<=end;i++)
2209  {
2210  if(weights[i-start]<0)
2211  {
2212  ord_struct.ord_typ=ro_wp_neg;
2213  break;
2214  }
2215  }
2216 }

◆ rO_WDegree64()

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

Definition at line 2240 of file ring.cc.

2242 {
2243  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1,
2244  // reserved 2 places
2245  rO_Align(place,bitplace);
2246  ord_struct.ord_typ=ro_wp64;
2247  ord_struct.data.wp64.start=start;
2248  ord_struct.data.wp64.end=end;
2249  ord_struct.data.wp64.place=place;
2250  ord_struct.data.wp64.weights64=weights;
2251  o[place]=1;
2252  place++;
2253  o[place]=1;
2254  place++;
2255  rO_Align(place,bitplace);
2256 }

◆ rO_WDegree_neg()

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

Definition at line 2258 of file ring.cc.

2260 {
2261  // weighted degree (aligned) of variables v_start..v_end, ordsgn -1
2262  while((start<end) && (weights[0]==0)) { start++; weights++; }
2263  while((start<end) && (weights[end-start]==0)) { end--; }
2264  rO_Align(place,bitplace);
2265  ord_struct.ord_typ=ro_wp;
2266  ord_struct.data.wp.start=start;
2267  ord_struct.data.wp.end=end;
2268  ord_struct.data.wp.place=place;
2269  ord_struct.data.wp.weights=weights;
2270  o[place]=-1;
2271  place++;
2272  rO_Align(place,bitplace);
2273  int i;
2274  for(i=start;i<=end;i++)
2275  {
2276  if(weights[i-start]<0)
2277  {
2278  ord_struct.ord_typ=ro_wp_neg;
2279  break;
2280  }
2281  }
2282 }

◆ rO_WMDegree()

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

Definition at line 2218 of file ring.cc.

2220 {
2221  assume(weights != NULL);
2222 
2223  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2224 // while((start<end) && (weights[0]==0)) { start++; weights++; }
2225 // while((start<end) && (weights[end-start]==0)) { end--; }
2226  rO_Align(place,bitplace);
2227  ord_struct.ord_typ=ro_am;
2228  ord_struct.data.am.start=start;
2229  ord_struct.data.am.end=end;
2230  ord_struct.data.am.place=place;
2231  ord_struct.data.am.weights=weights;
2232  ord_struct.data.am.weights_m = weights + (end-start+1);
2233  ord_struct.data.am.len_gen=weights[end-start+1];
2234  assume( ord_struct.data.am.weights_m[0] == ord_struct.data.am.len_gen );
2235  o[place]=1;
2236  place++;
2237  rO_Align(place,bitplace);
2238 }

◆ rOpposite()

ring rOpposite ( ring  src)

Definition at line 5250 of file ring.cc.

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

◆ rOppWeight()

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

Definition at line 5234 of file ring.cc.

5235 {
5236  /* works for commutative/Plural; need to be changed for Letterplace */
5237  /* Letterpace: each block of vars needs to be reverted on it own */
5238  int i2=(l+1)/2;
5239  for(int j=0; j<=i2; j++)
5240  {
5241  int t=w[j];
5242  w[j]=w[l-j];
5243  w[l-j]=t;
5244  }
5245 }

◆ rOptimizeLDeg()

static void rOptimizeLDeg ( ring  r)
static

Definition at line 3100 of file ring.cc.

3101 {
3102  if (r->pFDeg == p_Deg)
3103  {
3104  if (r->pLDeg == pLDeg1)
3105  r->pLDeg = pLDeg1_Deg;
3106  if (r->pLDeg == pLDeg1c)
3107  r->pLDeg = pLDeg1c_Deg;
3108  }
3109  else if (r->pFDeg == p_Totaldegree)
3110  {
3111  if (r->pLDeg == pLDeg1)
3112  r->pLDeg = pLDeg1_Totaldegree;
3113  if (r->pLDeg == pLDeg1c)
3114  r->pLDeg = pLDeg1c_Totaldegree;
3115  }
3116  else if (r->pFDeg == p_WFirstTotalDegree)
3117  {
3118  if (r->pLDeg == pLDeg1)
3119  r->pLDeg = pLDeg1_WFirstTotalDegree;
3120  if (r->pLDeg == pLDeg1c)
3121  r->pLDeg = pLDeg1c_WFirstTotalDegree;
3122  }
3123  r->pLDegOrig = r->pLDeg;
3124 }
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:970
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1033
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1063
long pLDeg1c_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:936
long pLDeg1(poly p, int *l, const ring r)
Definition: p_polys.cc:836
long pLDeg1_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:905
long pLDeg1c(poly p, int *l, const ring r)
Definition: p_polys.cc:872
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1000

◆ rOrd_is_MixedDegree_Ordering()

BOOLEAN rOrd_is_MixedDegree_Ordering ( ring  r)

Definition at line 3378 of file ring.cc.

3379 {
3380  int i;
3381  poly p=p_One(r);
3382  p_SetExp(p,1,1,r);
3383  p_Setm(p,r);
3384  int vz=sign(p_FDeg(p,r));
3385  for(i=2;i<=rVar(r);i++)
3386  {
3387  p_SetExp(p,i-1,0,r);
3388  p_SetExp(p,i,1,r);
3389  p_Setm(p,r);
3390  if (sign(p_FDeg(p,r))!=vz)
3391  {
3392  p_Delete(&p,r);
3393  return TRUE;
3394  }
3395  }
3396  p_Delete(&p,r);
3397  return FALSE;
3398 }
static long p_FDeg(const poly p, const ring r)
Definition: p_polys.h:380
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:861
static int sign(int x)
Definition: ring.cc:3377

◆ rOrd_is_Totaldegree_Ordering()

BOOLEAN rOrd_is_Totaldegree_Ordering ( const ring  r)

Definition at line 1927 of file ring.cc.

1928 {
1929  // Hmm.... what about Syz orderings?
1930  return (rVar(r) > 1 &&
1931  ((rHasSimpleOrder(r) &&
1932  (rOrder_is_DegOrdering((rRingOrder_t)r->order[0]) ||
1933  rOrder_is_DegOrdering(( rRingOrder_t)r->order[1]))) ||
1934  (rHasSimpleOrderAA(r) &&
1935  (rOrder_is_DegOrdering((rRingOrder_t)r->order[1]) ||
1936  ((r->order[1]!=0) &&
1937  rOrder_is_DegOrdering((rRingOrder_t)r->order[2]))))));
1938 }
BOOLEAN rOrder_is_DegOrdering(const rRingOrder_t order)
Definition: ring.cc:1842
BOOLEAN rHasSimpleOrderAA(ring r)
Definition: ring.cc:1876

◆ rOrd_is_WeightedDegree_Ordering()

BOOLEAN rOrd_is_WeightedDegree_Ordering ( const ring  r)

Definition at line 1941 of file ring.cc.

1942 {
1943  // Hmm.... what about Syz orderings?
1944  return ((rVar(r) > 1) &&
1945  rHasSimpleOrder(r) &&
1946  (rOrder_is_WeightedOrdering((rRingOrder_t)r->order[0]) ||
1947  rOrder_is_WeightedOrdering(( rRingOrder_t)r->order[1])));
1948 }
BOOLEAN rOrder_is_WeightedOrdering(rRingOrder_t order)
Definition: ring.cc:1861

◆ rOrd_SetCompRequiresSetm()

BOOLEAN rOrd_SetCompRequiresSetm ( const ring  r)

return TRUE if p_SetComp requires p_Setm

Definition at line 1907 of file ring.cc.

1908 {
1909  if (r->typ != NULL)
1910  {
1911  int pos;
1912  for (pos=0;pos<r->OrdSize;pos++)
1913  {
1914  sro_ord* o=&(r->typ[pos]);
1915  if ( (o->ord_typ == ro_syzcomp)
1916  || (o->ord_typ == ro_syz)
1917  || (o->ord_typ == ro_is)
1918  || (o->ord_typ == ro_am)
1919  || (o->ord_typ == ro_isTemp))
1920  return TRUE;
1921  }
1922  }
1923  return FALSE;
1924 }

◆ rOrder_is_DegOrdering()

BOOLEAN rOrder_is_DegOrdering ( const rRingOrder_t  order)

Definition at line 1842 of file ring.cc.

1843 {
1844  switch(order)
1845  {
1846  case ringorder_dp:
1847  case ringorder_Dp:
1848  case ringorder_ds:
1849  case ringorder_Ds:
1850  case ringorder_Ws:
1851  case ringorder_Wp:
1852  case ringorder_ws:
1853  case ringorder_wp:
1854  return TRUE;
1855 
1856  default:
1857  return FALSE;
1858  }
1859 }

◆ rOrder_is_WeightedOrdering()

BOOLEAN rOrder_is_WeightedOrdering ( rRingOrder_t  order)

Definition at line 1861 of file ring.cc.

1862 {
1863  switch(order)
1864  {
1865  case ringorder_Ws:
1866  case ringorder_Wp:
1867  case ringorder_ws:
1868  case ringorder_wp:
1869  return TRUE;
1870 
1871  default:
1872  return FALSE;
1873  }
1874 }

◆ rOrderName()

rRingOrder_t rOrderName ( char *  ordername)

Definition at line 506 of file ring.cc.

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

◆ rOrdStr()

char* rOrdStr ( ring  r)

Definition at line 520 of file ring.cc.

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

◆ rParStr()

char* rParStr ( ring  r)

Definition at line 647 of file ring.cc.

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

◆ rPlusVar()

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

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

Definition at line 5786 of file ring.cc.

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

◆ rRealloc1()

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

Definition at line 5211 of file ring.cc.

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

◆ rRightAdjustVarOffset()

static void rRightAdjustVarOffset ( ring  r)
static

right-adjust r->VarOffset

Definition at line 4032 of file ring.cc.

4033 {
4034  int* shifts = (int*) omAlloc(r->ExpL_Size*sizeof(int));
4035  int i;
4036  // initialize shifts
4037  for (i=0;i<r->ExpL_Size;i++)
4038  shifts[i] = BIT_SIZEOF_LONG;
4039 
4040  // find minimal bit shift in each long exp entry
4041  for (i=1;i<=r->N;i++)
4042  {
4043  if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
4044  shifts[r->VarOffset[i] & 0xffffff] = r->VarOffset[i] >> 24;
4045  }
4046  // reset r->VarOffset: set the minimal shift to 0
4047  for (i=1;i<=r->N;i++)
4048  {
4049  if (shifts[r->VarOffset[i] & 0xffffff] != 0)
4050  r->VarOffset[i]
4051  = (r->VarOffset[i] & 0xffffff) |
4052  (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[i] & 0xffffff]) << 24);
4053  }
4054  omFree(shifts);
4055 }

◆ rRing_has_CompLastBlock()

BOOLEAN rRing_has_CompLastBlock ( const ring  r)

Definition at line 5154 of file ring.cc.

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

◆ rRing_is_Homog()

BOOLEAN rRing_is_Homog ( const ring  r)

Definition at line 5132 of file ring.cc.

5133 {
5134  if (r == NULL) return FALSE;
5135  int i, j, nb = rBlocks(r);
5136  for (i=0; i<nb; i++)
5137  {
5138  if (r->wvhdl[i] != NULL)
5139  {
5140  int length = r->block1[i] - r->block0[i];
5141  int* wvhdl = r->wvhdl[i];
5142  if (r->order[i] == ringorder_M) length *= length;
5143  assume(omSizeOfAddr(wvhdl) >= length*sizeof(int));
5144 
5145  for (j=0; j< length; j++)
5146  {
5147  if (wvhdl[j] != 0 && wvhdl[j] != 1) return FALSE;
5148  }
5149  }
5150  }
5151  return TRUE;
5152 }
size_t omSizeOfAddr(const void *addr)

◆ rRing_ord_pure_dp()

BOOLEAN rRing_ord_pure_dp ( const ring  r)

Definition at line 5161 of file ring.cc.

5162 {
5163  if ((r->order[0]==ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5164  return TRUE;
5165  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5166  && ((r->order[1]==ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5167  return TRUE;
5168  return FALSE;
5169 }

◆ rRing_ord_pure_Dp()

BOOLEAN rRing_ord_pure_Dp ( const ring  r)

Definition at line 5171 of file ring.cc.

5172 {
5173  if ((r->order[0]==ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5174  return TRUE;
5175  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5176  && ((r->order[1]==ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5177  return TRUE;
5178  return FALSE;
5179 }

◆ rRing_ord_pure_lp()

BOOLEAN rRing_ord_pure_lp ( const ring  r)

Definition at line 5181 of file ring.cc.

5182 {
5183  if ((r->order[0]==ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5184  return TRUE;
5185  if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5186  && ((r->order[1]==ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5187  return TRUE;
5188  return FALSE;
5189 }

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

1714 {
1715  int i, j;
1716 
1717  if (r1 == r2) return TRUE;
1718 
1719  if (r1 == NULL || r2 == NULL) return FALSE;
1720 
1721  if ((r1->cf != r2->cf)
1722  || (rVar(r1) != rVar(r2))
1723  || (r1->OrdSgn != r2->OrdSgn))
1724  return FALSE;
1725 
1726  i=0;
1727  while (r1->order[i] != 0)
1728  {
1729  if (r2->order[i] == 0) return FALSE;
1730  if ((r1->order[i] != r2->order[i])
1731  || (r1->block0[i] != r2->block0[i])
1732  || (r1->block1[i] != r2->block1[i]))
1733  return FALSE;
1734  if (r1->wvhdl[i] != NULL)
1735  {
1736  if (r2->wvhdl[i] == NULL)
1737  return FALSE;
1738  for (j=0; j<r1->block1[i]-r1->block0[i]+1; j++)
1739  if (r2->wvhdl[i][j] != r1->wvhdl[i][j])
1740  return FALSE;
1741  }
1742  else if (r2->wvhdl[i] != NULL) return FALSE;
1743  i++;
1744  }
1745  if (r2->order[i] != 0) return FALSE;
1746 
1747  // we do not check variable names
1748  // we do not check minpoly/minideal
1749  // we do not check qideal
1750 
1751  return TRUE;
1752 }

◆ rSetDegStuff()

static void rSetDegStuff ( ring  r)
static

Definition at line 3127 of file ring.cc.

3128 {
3129  rRingOrder_t* order = r->order;
3130  int* block0 = r->block0;
3131  int* block1 = r->block1;
3132  int** wvhdl = r->wvhdl;
3133 
3134  if (order[0]==ringorder_S ||order[0]==ringorder_s || order[0]==ringorder_IS)
3135  {
3136  order++;
3137  block0++;
3138  block1++;
3139  wvhdl++;
3140  }
3141  r->LexOrder = FALSE;
3142  r->pFDeg = p_Totaldegree;
3143  r->pLDeg = (r->OrdSgn == 1 ? pLDegb : pLDeg0);
3144 
3145  /*======== ordering type is (am,_) ==================*/
3146  if (order[0]==ringorder_am)
3147  {
3148  for(int ii=block0[0];ii<=block1[0];ii++)
3149  if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
3150  r->LexOrder=FALSE;
3151  for(int ii=block0[0];ii<=block1[0];ii++)
3152  if (wvhdl[0][ii-1]==0) { r->LexOrder=TRUE;break;}
3153  if ((block0[0]==1)&&(block1[0]==r->N))
3154  {
3155  r->pFDeg = p_Deg;
3156  r->pLDeg = pLDeg1c_Deg;
3157  }
3158  else
3159  {
3160  r->pFDeg = p_WTotaldegree;
3161  r->LexOrder=TRUE;
3162  r->pLDeg = pLDeg1c_WFirstTotalDegree;
3163  }
3164  r->firstwv = wvhdl[0];
3165  }
3166  /*======== ordering type is (_,c) =========================*/
3167  else if ((order[0]==ringorder_unspec) || (order[1] == 0)
3168  ||(
3169  ((order[1]==ringorder_c)||(order[1]==ringorder_C)
3170  ||(order[1]==ringorder_S)
3171  ||(order[1]==ringorder_s))
3172  && (order[0]!=ringorder_M)
3173  && (order[2]==0))
3174  )
3175  {
3176  if (r->OrdSgn == -1) r->pLDeg = pLDeg0c;
3177  if ((order[0] == ringorder_lp)
3178  || (order[0] == ringorder_ls)
3179  || (order[0] == ringorder_rp)
3180  || (order[0] == ringorder_rs))
3181  {
3182  r->LexOrder=TRUE;
3183  r->pLDeg = pLDeg1c;
3184  r->pFDeg = p_Totaldegree;
3185  }
3186  else if ((order[0] == ringorder_a)
3187  || (order[0] == ringorder_wp)
3188  || (order[0] == ringorder_Wp))
3189  {
3190  r->pFDeg = p_WFirstTotalDegree;
3191  }
3192  else if ((order[0] == ringorder_ws)
3193  || (order[0] == ringorder_Ws))
3194  {
3195  for(int ii=block0[0];ii<=block1[0];ii++)
3196  {
3197  if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
3198  }
3199  if (r->MixedOrder==0)
3200  {
3201  if ((block0[0]==1)&&(block1[0]==r->N))
3202  r->pFDeg = p_WTotaldegree;
3203  else
3204  r->pFDeg = p_WFirstTotalDegree;
3205  }
3206  else
3207  r->pFDeg = p_Totaldegree;
3208  }
3209  r->firstBlockEnds=block1[0];
3210  r->firstwv = wvhdl[0];
3211  }
3212  /*======== ordering type is (c,_) =========================*/
3213  else if (((order[0]==ringorder_c)
3214  ||(order[0]==ringorder_C)
3215  ||(order[0]==ringorder_S)
3216  ||(order[0]==ringorder_s))
3217  && (order[1]!=ringorder_M)
3218  && (order[2]==0))
3219  {
3220  if ((order[1] == ringorder_lp)
3221  || (order[1] == ringorder_ls)
3222  || (order[1] == ringorder_rp)
3223  || order[1] == ringorder_rs)
3224  {
3225  r->LexOrder=TRUE;
3226  r->pLDeg = pLDeg1c;
3227  r->pFDeg = p_Totaldegree;
3228  }
3229  r->firstBlockEnds=block1[1];
3230  if (wvhdl!=NULL) r->firstwv = wvhdl[1];
3231  if ((order[1] == ringorder_a)
3232  || (order[1] == ringorder_wp)
3233  || (order[1] == ringorder_Wp))
3234  r->pFDeg = p_WFirstTotalDegree;
3235  else if ((order[1] == ringorder_ws)
3236  || (order[1] == ringorder_Ws))
3237  {
3238  for(int ii=block0[1];ii<=block1[1];ii++)
3239  if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;break;}
3240  if (r->MixedOrder==FALSE)
3241  r->pFDeg = p_WFirstTotalDegree;
3242  else
3243  r->pFDeg = p_Totaldegree;
3244  }
3245  }
3246  /*------- more than one block ----------------------*/
3247  else
3248  {
3249  if ((r->VectorOut)||(order[0]==ringorder_C)||(order[0]==ringorder_S)||(order[0]==ringorder_s))
3250  {
3251  rSetFirstWv(r, 1, order, block1, wvhdl);
3252  }
3253  else
3254  rSetFirstWv(r, 0, order, block1, wvhdl);
3255 
3256  if ((order[0]!=ringorder_c)
3257  && (order[0]!=ringorder_C)
3258  && (order[0]!=ringorder_S)
3259  && (order[0]!=ringorder_s))
3260  {
3261  r->pLDeg = pLDeg1c;
3262  }
3263  else
3264  {
3265  r->pLDeg = pLDeg1;
3266  }
3267  r->pFDeg = p_WTotaldegree; // may be improved: p_Totaldegree for lp/dp/ls/.. blocks
3268  }
3269 
3272  {
3273  if(r->MixedOrder==FALSE)
3274  r->pFDeg = p_Deg;
3275  else
3276  r->pFDeg = p_Totaldegree;
3277  }
3278 
3279  if( rGetISPos(0, r) != -1 ) // Are there Schreyer induced blocks?
3280  {
3281 #ifndef SING_NDEBUG
3282  assume( r->pFDeg == p_Deg || r->pFDeg == p_WTotaldegree || r->pFDeg == p_Totaldegree);
3283 #endif
3284 
3285  r->pLDeg = pLDeg1; // ?
3286  }
3287 
3288  r->pFDegOrig = r->pFDeg;
3289  // NOTE: this leads to wrong ecart during std
3290  // in Old/sre.tst
3291  rOptimizeLDeg(r); // also sets r->pLDegOrig
3292 }
if(yy_init)
Definition: libparse.cc:1420
long pLDegb(poly p, int *l, const ring r)
Definition: p_polys.cc:806
long pLDeg0c(poly p, int *l, const ring r)
Definition: p_polys.cc:765
long pLDeg0(poly p, int *l, const ring r)
Definition: p_polys.cc:734
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:4947
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
Definition: ring.cc:1927
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block1, int **wvhdl)
Definition: ring.cc:3068

◆ rSetFirstWv()

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

Definition at line 3068 of file ring.cc.

3069 {
3070  // cheat for ringorder_aa
3071  if (order[i] == ringorder_aa)
3072  i++;
3073  if(block1[i]!=r->N) r->LexOrder=TRUE;
3074  r->firstBlockEnds=block1[i];
3075  r->firstwv = wvhdl[i];
3076  if ((order[i]== ringorder_ws)
3077  || (order[i]==ringorder_Ws)
3078  || (order[i]== ringorder_wp)
3079  || (order[i]==ringorder_Wp)
3080  || (order[i]== ringorder_a)
3081  /*|| (order[i]==ringorder_A)*/)
3082  {
3083  int j;
3084  for(j=block1[i]-r->block0[i];j>=0;j--)
3085  {
3086  if (r->firstwv[j]==0) r->LexOrder=TRUE;
3087  }
3088  }
3089  else if (order[i]==ringorder_a64)
3090  {
3091  int j;
3092  int64 *w=rGetWeightVec(r);
3093  for(j=block1[i]-r->block0[i];j>=0;j--)
3094  {
3095  if (w[j]==0) r->LexOrder=TRUE;
3096  }
3097  }
3098 }
int64 * rGetWeightVec(const ring r)
Definition: ring.cc:5191

◆ 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 allright!

Definition at line 4979 of file ring.cc.

4980 {
4981  // Put the reference set F into the ring -ordering -recor
4982 
4983  if (r->typ==NULL)
4984  {
4985  dReportError("Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
4986  return FALSE;
4987  }
4988 
4989 
4990  int pos = rGetISPos(p, r);
4991 
4992  if( pos == -1 )
4993  {
4994  dReportError("Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
4995  return FALSE;
4996  }
4997 
4998 #if MYTEST
4999  if( i != r->typ[pos].data.is.limit )
5000  Print("Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
5001 #endif
5002 
5003  const ideal FF = idrHeadR(F, r, r); // id_Copy(F, r); // ???
5004 
5005 
5006  if( r->typ[pos].data.is.F != NULL)
5007  {
5008 #if MYTEST
5009  PrintS("Deleting old reference set F... \n"); // idShow(r->typ[pos].data.is.F, r); PrintLn();
5010 #endif
5011  id_Delete(&r->typ[pos].data.is.F, r);
5012  r->typ[pos].data.is.F = NULL;
5013  }
5014 
5015  assume(r->typ[pos].data.is.F == NULL);
5016 
5017  r->typ[pos].data.is.F = FF; // F is owened by ring now! TODO: delete at the end!
5018 
5019  r->typ[pos].data.is.limit = i; // First induced component
5020 
5021 #if MYTEST
5022  PrintS("New reference set FF : \n"); idShow(FF, r, r, 1); PrintLn();
5023 #endif
5024 
5025  return TRUE;
5026 }
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
Definition: simpleideals.cc:57

◆ rSetNegWeight()

static void rSetNegWeight ( ring  r)
static

Definition at line 3297 of file ring.cc.

3298 {
3299  int i,l;
3300  if (r->typ!=NULL)
3301  {
3302  l=0;
3303  for(i=0;i<r->OrdSize;i++)
3304  {
3305  if((r->typ[i].ord_typ==ro_wp_neg)
3306  ||(r->typ[i].ord_typ==ro_am))
3307  l++;
3308  }
3309  if (l>0)
3310  {
3311  r->NegWeightL_Size=l;
3312  r->NegWeightL_Offset=(int *) omAlloc(l*sizeof(int));
3313  l=0;
3314  for(i=0;i<r->OrdSize;i++)
3315  {
3316  if(r->typ[i].ord_typ==ro_wp_neg)
3317  {
3318  r->NegWeightL_Offset[l]=r->typ[i].data.wp.place;
3319  l++;
3320  }
3321  else if(r->typ[i].ord_typ==ro_am)
3322  {
3323  r->NegWeightL_Offset[l]=r->typ[i].data.am.place;
3324  l++;
3325  }
3326  }
3327  return;
3328  }
3329  }
3330  r->NegWeightL_Size = 0;
3331  r->NegWeightL_Offset = NULL;
3332 }

◆ rSetOption()

static void rSetOption ( ring  r)
static

Definition at line 3334 of file ring.cc.

3335 {
3336  // set redthrough
3337  if (!TEST_OPT_OLDSTD && r->OrdSgn == 1 && ! r->LexOrder)
3338  r->options |= Sy_bit(OPT_REDTHROUGH);
3339  else
3340  r->options &= ~Sy_bit(OPT_REDTHROUGH);
3341 
3342  // set intStrategy
3343  if ( (r->cf->extRing!=NULL)
3344  || rField_is_Q(r)
3345  || rField_is_Ring(r)
3346  )
3347  r->options |= Sy_bit(OPT_INTSTRATEGY);
3348  else
3349  r->options &= ~Sy_bit(OPT_INTSTRATEGY);
3350 
3351  // set redTail
3352  if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=NULL))
3353  r->options &= ~Sy_bit(OPT_REDTAIL);
3354  else
3355  r->options |= Sy_bit(OPT_REDTAIL);
3356 }
#define OPT_INTSTRATEGY
Definition: options.h:92
#define OPT_REDTAIL
Definition: options.h:91
#define TEST_OPT_OLDSTD
Definition: options.h:123
#define OPT_REDTHROUGH
Definition: options.h:82
#define Sy_bit(x)
Definition: options.h:31
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:486
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:508

◆ rSetOutParams()

static void rSetOutParams ( ring  r)
static

Definition at line 3025 of file ring.cc.

3026 {
3027  r->VectorOut = (r->order[0] == ringorder_c);
3028  if (rIsNCRing(r))
3029  r->CanShortOut=FALSE;
3030  else
3031  {
3032  r->CanShortOut = TRUE;
3033  int i;
3034  if (rParameter(r)!=NULL)
3035  {
3036  for (i=0;i<rPar(r);i++)
3037  {
3038  if(strlen(rParameter(r)[i])>1)
3039  {
3040  r->CanShortOut=FALSE;
3041  break;
3042  }
3043  }
3044  }
3045  if (r->CanShortOut)
3046  {
3047  // Hmm... sometimes (e.g., from maGetPreimage) new variables
3048  // are introduced, but their names are never set
3049  // hence, we do the following awkward trick
3050  int N = omSizeOfAddr(r->names)/sizeof(char_ptr);
3051  if (r->N < N) N = r->N;
3052 
3053  for (i=(N-1);i>=0;i--)
3054  {
3055  if(r->names[i] != NULL && strlen(r->names[i])>1)
3056  {
3057  r->CanShortOut=FALSE;
3058  break;
3059  }
3060  }
3061  }
3062  }
3063  r->ShortOut = r->CanShortOut;
3064 
3065  assume( !( !r->CanShortOut && r->ShortOut ) );
3066 }
char * char_ptr
Definition: ring.cc:42
static BOOLEAN rIsNCRing(const ring r)
Definition: ring.h:421

◆ rSetSyzComp()

void rSetSyzComp ( int  k,
const ring  r 
)

Definition at line 5033 of file ring.cc.

5034 {
5035  if(k < 0)
5036  {
5037  dReportError("rSetSyzComp with negative limit!");
5038  return;
5039  }
5040 
5041  assume( k >= 0 );
5042  if (TEST_OPT_PROT) Print("{%d}", k);
5043  if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz))
5044  {
5045  r->block0[0]=r->block1[0] = k;
5046  if( k == r->typ[0].data.syz.limit )
5047  return; // nothing to do
5048 
5049  int i;
5050  if (r->typ[0].data.syz.limit == 0)
5051  {
5052  r->typ[0].data.syz.syz_index = (int*) omAlloc0((k+1)*sizeof(int));
5053  r->typ[0].data.syz.syz_index[0] = 0;
5054  r->typ[0].data.syz.curr_index = 1;
5055  }
5056  else
5057  {
5058  r->typ[0].data.syz.syz_index = (int*)
5059  omReallocSize(r->typ[0].data.syz.syz_index,
5060  (r->typ[0].data.syz.limit+1)*sizeof(int),
5061  (k+1)*sizeof(int));
5062  }
5063  for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
5064  {
5065  r->typ[0].data.syz.syz_index[i] =
5066  r->typ[0].data.syz.curr_index;
5067  }
5068  if(k < r->typ[0].data.syz.limit) // ?
5069  {
5070 #ifndef SING_NDEBUG
5071  Warn("rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
5072 #endif
5073  r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[k];
5074  }
5075 
5076 
5077  r->typ[0].data.syz.limit = k;
5078  r->typ[0].data.syz.curr_index++;
5079  }
5080  else if(
5081  (r->typ!=NULL) &&
5082  (r->typ[0].ord_typ==ro_isTemp)
5083  )
5084  {
5085 // (r->typ[currRing->typ[0].data.isTemp.suffixpos].data.is.limit == k)
5086 #ifndef SING_NDEBUG
5087  Warn("rSetSyzComp(%d) in an IS ring! Be careful!", k);
5088 #endif
5089  }
5090  else if (r->order[0]==ringorder_s)
5091  {
5092  r->block0[0] = r->block1[0] = k;
5093  }
5094  else if (r->order[0]!=ringorder_c)
5095  {
5096  dReportError("syzcomp in incompatible ring");
5097  }
5098 #ifdef PDEBUG
5099  EXTERN_VAR int pDBsyzComp;
5100  pDBsyzComp=k;
5101 #endif
5102 }
#define EXTERN_VAR
Definition: globaldefs.h:6
#define TEST_OPT_PROT
Definition: options.h:103
VAR int pDBsyzComp
Definition: ring.cc:5029

◆ rSetVarL()

static void rSetVarL ( ring  r)
static

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

Definition at line 3977 of file ring.cc.

3978 {
3979  int min = MAX_INT_VAL, min_j = -1;
3980  int* VarL_Number = (int*) omAlloc0(r->ExpL_Size*sizeof(int));
3981 
3982  int i,j;
3983 
3984  // count how often a var long is occupied by an exponent
3985  for (i=1; i<=r->N; i++)
3986  {
3987  VarL_Number[r->VarOffset[i] & 0xffffff]++;
3988  }
3989 
3990  // determine how many and min
3991  for (i=0, j=0; i<r->ExpL_Size; i++)
3992  {
3993  if (VarL_Number[i] != 0)
3994  {
3995  if (min > VarL_Number[i])
3996  {
3997  min = VarL_Number[i];
3998  min_j = j;
3999  }
4000  j++;
4001  }
4002  }
4003 
4004  r->VarL_Size = j; // number of long with exp. entries in
4005  // in p->exp
4006  r->VarL_Offset = (int*) omAlloc(r->VarL_Size*sizeof(int));
4007  r->VarL_LowIndex = 0;
4008 
4009  // set VarL_Offset
4010  for (i=0, j=0; i<r->ExpL_Size; i++)
4011  {
4012  if (VarL_Number[i] != 0)
4013  {
4014  r->VarL_Offset[j] = i;
4015  if (j > 0 && r->VarL_Offset[j-1] != r->VarL_Offset[j] - 1)
4016  r->VarL_LowIndex = -1;
4017  j++;
4018  }
4019  }
4020  if (r->VarL_LowIndex >= 0)
4021  r->VarL_LowIndex = r->VarL_Offset[0];
4022 
4023  if (min_j != 0)
4024  {
4025  j = r->VarL_Offset[min_j];
4026  r->VarL_Offset[min_j] = r->VarL_Offset[0];
4027  r->VarL_Offset[0] = j;
4028  }
4029  omFree(VarL_Number);
4030 }
static int min(int a, int b)
Definition: fast_mult.cc:268

◆ rSetWeightVec()

void rSetWeightVec ( ring  r,
int64 wv 
)

Definition at line 5201 of file ring.cc.

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

◆ rSimpleOrdStr()

const char* rSimpleOrdStr ( int  ord)

Definition at line 77 of file ring.cc.

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

◆ rString()

char* rString ( ring  r)

Definition at line 671 of file ring.cc.

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

◆ rSum()

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

Definition at line 1344 of file ring.cc.

1345 {
1346  if ((r1==NULL)||(r2==NULL)
1347  ||(r1->cf==NULL)||(r2->cf==NULL))
1348  return -1;
1349  if (r1==r2)
1350  {
1351  sum=r1;
1352  rIncRefCnt(r1);
1353  return 0;
1354  }
1355  return rSumInternal(r1,r2,sum,TRUE,FALSE);
1356 }
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:747
static ring rIncRefCnt(ring r)
Definition: ring.h:844

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

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

◆ rTypeOfMatrixOrder()

int rTypeOfMatrixOrder ( const intvec order)

Definition at line 185 of file ring.cc.

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

◆ rUnComplete()

void rUnComplete ( ring  r)

Definition at line 3915 of file ring.cc.

3916 {
3917  if (r == NULL) return;
3918  if (r->VarOffset != NULL)
3919  {
3920  if (r->OrdSize!=0 && r->typ != NULL)
3921  {
3922  for(int i = 0; i < r->OrdSize; i++)
3923  if( r->typ[i].ord_typ == ro_is) // Search for suffixes! (prefix have the same VarOffset)
3924  {
3925  id_Delete(&r->typ[i].data.is.F, r);
3926 
3927  if( r->typ[i].data.is.pVarOffset != NULL )
3928  {
3929  omFreeSize((ADDRESS)r->typ[i].data.is.pVarOffset, (r->N +1)*sizeof(int));
3930  }
3931  }
3932  else if (r->typ[i].ord_typ == ro_syz)
3933  {
3934  if(r->typ[i].data.syz.limit > 0)
3935  omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*sizeof(int));
3936  }
3937  else if (r->typ[i].ord_typ == ro_syzcomp)
3938  {
3939  assume( r->typ[i].data.syzcomp.ShiftedComponents == NULL );
3940  assume( r->typ[i].data.syzcomp.Components == NULL );
3941 // WarnS( "rUnComplete : ord_typ == ro_syzcomp was unhandled!!! Possibly memory leak!!!" );
3942 #ifndef SING_NDEBUG
3943 // assume(0);
3944 #endif
3945  }
3946 
3947  omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord)); r->typ = NULL;
3948  }
3949 
3950  if (r->PolyBin != NULL)
3951  omUnGetSpecBin(&(r->PolyBin));
3952 
3953  omFreeSize((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
3954  r->VarOffset=NULL;
3955 
3956  if (r->ordsgn != NULL && r->CmpL_Size != 0)
3957  {
3958  omFreeSize((ADDRESS)r->ordsgn,r->ExpL_Size*sizeof(long));
3959  r->ordsgn=NULL;
3960  }
3961  if (r->p_Procs != NULL)
3962  {
3963  omFreeSize(r->p_Procs, sizeof(p_Procs_s));
3964  r->p_Procs=NULL;
3965  }
3966  omfreeSize(r->VarL_Offset, r->VarL_Size*sizeof(int));
3967  r->VarL_Offset=NULL;
3968  }
3969  if (r->NegWeightL_Offset!=NULL)
3970  {
3971  omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*sizeof(int));
3972  r->NegWeightL_Offset=NULL;
3973  }
3974 }
#define omfreeSize(addr, size)
Definition: omAllocDecl.h:236
#define omUnGetSpecBin(bin_ptr)
Definition: omBin.h:14

◆ rVarStr()

char* rVarStr ( ring  r)

Definition at line 621 of file ring.cc.

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

◆ rWrite()

void rWrite ( ring  r,
BOOLEAN  details 
)

Definition at line 226 of file ring.cc.

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

◆ sign()

static int sign ( int  x)
inlinestatic

Definition at line 3377 of file ring.cc.

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

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

◆ ringorder_name

const char* const ringorder_name[]
static
Initial value:
=
{
" ?",
"a",
"A",
"c",
"C",
"M",
"S",
"s",
"lp",
"dp",
"rp",
"Dp",
"wp",
"Wp",
"ls",
"ds",
"Ds",
"ws",
"Ws",
"am",
"L",
"aa",
"rs",
"IS",
" _"
}

Definition at line 47 of file ring.cc.

◆ sip_sring_bin

VAR omBin sip_sring_bin = omGetSpecBin(sizeof(ip_sring))

Definition at line 43 of file ring.cc.