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 rDBTest (ring r, const char *fn, const int l)
 
static void rO_Align (int &place, int &bitplace)
 
static void rO_TDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
 
static void rO_TDegree_neg (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
 
static void rO_WDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
 
static void rO_WMDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
 
static void rO_WDegree64 (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
 
static void rO_WDegree_neg (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
 
static void rO_LexVars (int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
 
static void rO_LexVars_neg (int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
 
static void rO_Syzcomp (int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
 
static void rO_Syz (int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
 
static void rO_ISPrefix (int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
 
static void rO_ISSuffix (int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
 
static unsigned long rGetExpSize (unsigned long bitmask, int &bits)
 
unsigned long rGetExpSize (unsigned long bitmask, int &bits, int N)
 
ring rModifyRing (ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
 
ring rModifyRing_Wp (ring r, int *weights)
 construct Wp, C ring 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 *block0, int *block1, int **wvhdl)
 
static void rSetDegStuff (ring r)
 
static void rSetNegWeight (ring r)
 
static void rSetOption (ring r)
 
static void rCheckOrdSgn (ring r, int i)
 
void p_SetGlobals (const ring r, BOOLEAN complete)
 set all properties of a new ring - also called by rComplete 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...
 
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_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)
 
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 2453 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 5278 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 4350 of file ring.cc.

4351 {
4352  Print("\nexp[0..%d]\n", R->ExpL_Size - 1);
4353  for(int i = 0; i < R->ExpL_Size; i++)
4354  Print("%09lx ", p->exp[i]);
4355  PrintLn();
4356  Print("v0:%9ld ", p_GetComp(p, R));
4357  for(int i = 1; i <= R->N; i++) Print(" v%d:%5ld",i, p_GetExp(p, i, R));
4358  PrintLn();
4359 }
int i
Definition: cfEzgcd.cc:132
int p
Definition: cfModGcd.cc:4078
#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:467
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 5773 of file ring.cc.

5774 {
5775  assume(r != NULL);
5776  const coeffs C = r->cf;
5777  assume(C != NULL);
5778 
5780 
5781  const n_coeffType _filed_type = getCoeffType(C);
5782 
5783  if(( _filed_type == n_algExt )||( _filed_type == n_polyExt ))
5784  return naIsParam(m, C);
5785 
5786  if( _filed_type == n_transExt )
5787  return ntIsParam(m, C);
5788 
5789  Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C));
5790 
5791  return 0;
5792 }
int naIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition: algext.cc:1106
int m
Definition: cfEzgcd.cc:128
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:843
n_coeffType
Definition: coeffs.h:27
@ n_polyExt
used to represent polys as coeffcients
Definition: coeffs.h:34
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition: coeffs.h:35
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
#define assume(x)
Definition: mod2.h:389
The main handler for Singular numbers which are suitable for Singular polynomials.
#define NULL
Definition: omList.c:12
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int ntIsParam(number m, const coeffs cf)
if m == var(i)/1 => return i,
Definition: transext.cc:2308

◆ nc_rComplete()

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

Definition at line 5685 of file ring.cc.

5690 {
5691 // NOTE: Originally used only by idElimination to transfer NC structure to dest
5692 // ring created by dirty hack (without nc_CallPlural)
5693  rTest(src);
5694 
5695  assume(!rIsPluralRing(dest)); // destination must be a newly constructed commutative ring
5696 
5697  if (!rIsPluralRing(src))
5698  {
5699  return FALSE;
5700  }
5701 
5702  const int N = dest->N;
5703 
5704  assume(src->N == N);
5705 
5706 // ring save = currRing;
5707 
5708 // if (dest != save)
5709 // rChangeCurrRing(dest);
5710 
5711  const ring srcBase = src;
5712 
5713  assume( n_SetMap(srcBase->cf,dest->cf) == n_SetMap(dest->cf,dest->cf) ); // currRing is important here!
5714 
5715  matrix C = mpNew(N,N); // ring independent
5716  matrix D = mpNew(N,N);
5717 
5718  matrix C0 = src->GetNC()->C;
5719  matrix D0 = src->GetNC()->D;
5720 
5721  // map C and D into dest
5722  for (int i = 1; i < N; i++)
5723  {
5724  for (int j = i + 1; j <= N; j++)
5725  {
5726  const number n = n_Copy(p_GetCoeff(MATELEM(C0,i,j), srcBase), srcBase->cf); // src, mapping for coeffs into currRing = dest!
5727  const poly p = p_NSet(n, dest);
5728  MATELEM(C,i,j) = p;
5729  if (MATELEM(D0,i,j) != NULL)
5730  MATELEM(D,i,j) = prCopyR(MATELEM(D0,i,j), srcBase, dest); // ?
5731  }
5732  }
5733  /* One must test C and D _only_ in r->GetNC()->basering!!! not in r!!! */
5734 
5735  id_Test((ideal)C, dest);
5736  id_Test((ideal)D, dest);
5737 
5738  if (nc_CallPlural(C, D, NULL, NULL, dest, bSetupQuotient, false, true, dest)) // also takes care about quotient ideal
5739  {
5740  //WarnS("Error transferring non-commutative structure");
5741  // error message should be in the interpreter interface
5742 
5743  mp_Delete(&C, dest);
5744  mp_Delete(&D, dest);
5745 
5746 // if (currRing != save)
5747 // rChangeCurrRing(save);
5748 
5749  return TRUE;
5750  }
5751 
5752 // mp_Delete(&C, dest); // used by nc_CallPlural!
5753 // mp_Delete(&D, dest);
5754 
5755 // if (dest != save)
5756 // rChangeCurrRing(save);
5757 
5758  assume(rIsPluralRing(dest));
5759  return FALSE;
5760 }
#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:448
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:697
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:2690
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:1469
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:782
#define id_Test(A, lR)
Definition: simpleideals.h:87

◆ nc_rCreateNCcomm_rCopy()

ring nc_rCreateNCcomm_rCopy ( ring  r)

Definition at line 719 of file ring.cc.

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

◆ p_DebugPrint()

void p_DebugPrint ( poly  p,
const ring  r 
)

Definition at line 4327 of file ring.cc.

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

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

◆ r_IsRingVar()

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

Definition at line 212 of file ring.cc.

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

◆ rAssure_C_dp()

ring rAssure_C_dp ( const ring  r)

Definition at line 4985 of file ring.cc.

4986 {
4988 }
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
Definition: ring.cc:4804
@ 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 4990 of file ring.cc.

4991 {
4993 }
@ 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 4694 of file ring.cc.

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

◆ rAssure_dp_C()

ring rAssure_dp_C ( const ring  r)

Definition at line 4980 of file ring.cc.

4981 {
4983 }

◆ rAssure_dp_S()

ring rAssure_dp_S ( const ring  r)

Definition at line 4975 of file ring.cc.

4976 {
4978 }
@ 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 4804 of file ring.cc.

4805 {
4806  int r_blocks = rBlocks(r);
4807 
4808  assume(b1 == ringorder_c || b1 == ringorder_C ||
4809  b2 == ringorder_c || b2 == ringorder_C ||
4810  b2 == ringorder_S);
4811  if ((r_blocks == 3) &&
4812  (r->order[0] == b1) &&
4813  (r->order[1] == b2) &&
4814  (r->order[2] == 0))
4815  return r;
4816  ring res = rCopy0(r, FALSE, FALSE);
4817  res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
4818  res->block0 = (int*)omAlloc0(3*sizeof(int));
4819  res->block1 = (int*)omAlloc0(3*sizeof(int));
4820  res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
4821  res->order[0] = b1;
4822  res->order[1] = b2;
4823  if (b1 == ringorder_c || b1 == ringorder_C)
4824  {
4825  res->block0[1] = 1;
4826  res->block1[1] = r->N;
4827  }
4828  else
4829  {
4830  res->block0[0] = 1;
4831  res->block1[0] = r->N;
4832  }
4833  rComplete(res, 1);
4834  if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4835 #ifdef HAVE_PLURAL
4836  if (rIsPluralRing(r))
4837  {
4838  if ( nc_rComplete(r, res, false) ) // no qideal!
4839  {
4840 #ifndef SING_NDEBUG
4841  WarnS("error in nc_rComplete");
4842 #endif
4843  }
4844  }
4845 #endif
4846 // rChangeCurrRing(res);
4847  return res;
4848 }
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:205
rRingOrder_t
order stuff
Definition: ring.h:68

◆ rAssure_HasComp()

ring rAssure_HasComp ( const ring  r)

Definition at line 4625 of file ring.cc.

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

◆ rAssure_InducedSchreyerOrdering()

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

Definition at line 4850 of file ring.cc.

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

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

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

◆ rAssure_SyzOrder()

ring rAssure_SyzOrder ( const ring  r,
BOOLEAN  complete 
)

Definition at line 4430 of file ring.cc.

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

◆ rAssure_TDeg()

ring rAssure_TDeg ( ring  r,
int &  pos 
)

Definition at line 4527 of file ring.cc.

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

4406 {
4407 #ifdef PDEBUG
4408  rDBChangeSComps(currComponents, currShiftedComponents, length, r);
4409 #else
4410  rNChangeSComps(currComponents, currShiftedComponents, r);
4411 #endif
4412 }
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
Definition: ring.cc:4367
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4383
EXTERN_VAR long * currShiftedComponents
Definition: syz.h:118

◆ rChar()

int rChar ( ring  r)

Definition at line 713 of file ring.cc.

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

◆ rCharStr()

char* rCharStr ( const ring  r)

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

Definition at line 647 of file ring.cc.

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

◆ rCheckIV()

BOOLEAN rCheckIV ( const intvec iv)

Definition at line 175 of file ring.cc.

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

◆ rCheckOrdSgn()

static void rCheckOrdSgn ( ring  r,
int  i 
)
static

Definition at line 3852 of file ring.cc.

3853 { // set r->OrdSgn, r->MixedOrder
3854  // for each variable:
3855  int nonpos=0;
3856  int nonneg=0;
3857  for(int i=1;i<=r->N;i++)
3858  {
3859  int found=0;
3860  // for all blocks:
3861  for(int j=0;(j<=b) && (found==0);j++)
3862  {
3863  // search the first block containing var(i)
3864  if ((r->block0[j]<=i)&&(r->block1[j]>=i))
3865  {
3866  // what kind if block is it?
3867  if ((r->order[j]==ringorder_ls)
3868  || (r->order[j]==ringorder_ds)
3869  || (r->order[j]==ringorder_Ds)
3870  || (r->order[j]==ringorder_ws)
3871  || (r->order[j]==ringorder_Ws)
3872  || (r->order[j]==ringorder_rs))
3873  {
3874  r->OrdSgn=-1;
3875  nonpos++;
3876  found=1;
3877  }
3878  else if((r->order[j]==ringorder_a)
3879  ||(r->order[j]==ringorder_aa))
3880  {
3881  // <0: local/mixed ordering
3882  // >0: var(i) is okay, look at other vars
3883  // ==0: look at other blocks for var(i)
3884  if(r->wvhdl[j][i-r->block0[j]]<0)
3885  {
3886  r->OrdSgn=-1;
3887  nonpos++;
3888  found=1;
3889  }
3890  else if(r->wvhdl[j][i-r->block0[j]]>0)
3891  {
3892  nonneg++;
3893  found=1;
3894  }
3895  }
3896  else if(r->order[j]==ringorder_M)
3897  {
3898  // <0: local/mixed ordering
3899  // >0: var(i) is okay, look at other vars
3900  // ==0: look at other blocks for var(i)
3901  if(r->wvhdl[j][i-r->block0[j]]<0)
3902  {
3903  r->OrdSgn=-1;
3904  nonpos++;
3905  found=1;
3906  }
3907  else if(r->wvhdl[j][i-r->block0[j]]>0)
3908  {
3909  nonneg++;
3910  found=1;
3911  }
3912  else
3913  {
3914  // very bad: try next row(s)
3915  int add=r->block1[j]-r->block0[j]+1;
3916  int max_i=r->block0[j]+add*add-add-1;
3917  while(found==0)
3918  {
3919  i+=add;
3920  if (r->wvhdl[j][i-r->block0[j]]<0)
3921  {
3922  r->OrdSgn=-1;
3923  nonpos++;
3924  found=1;
3925  }
3926  else if(r->wvhdl[j][i-r->block0[j]]>0)
3927  {
3928  nonneg++;
3929  found=1;
3930  }
3931  else if(i>max_i)
3932  {
3933  nonpos++;
3934  nonneg++;
3935  found=1;
3936  }
3937  }
3938  }
3939  }
3940  else if ((r->order[j]==ringorder_lp)
3941  || (r->order[j]==ringorder_dp)
3942  || (r->order[j]==ringorder_Dp)
3943  || (r->order[j]==ringorder_wp)
3944  || (r->order[j]==ringorder_Wp)
3945  || (r->order[j]==ringorder_rp))
3946  {
3947  found=1;
3948  nonneg++;
3949  }
3950  }
3951  }
3952  }
3953  if (nonpos>0)
3954  {
3955  r->OrdSgn=-1;
3956  if (nonneg>0) r->MixedOrder=1;
3957  }
3958  else
3959  {
3960  r->OrdSgn=1;
3961  r->MixedOrder=0;
3962  }
3963 }
CanonicalForm b
Definition: cfModGcd.cc:4103
bool found
Definition: facFactorize.cc:55
STATIC_VAR unsigned add[]
Definition: misc_ip.cc:107
@ 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

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

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

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

◆ rCopy0()

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

Definition at line 1421 of file ring.cc.

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

◆ rCopy0AndAddA()

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

Definition at line 1564 of file ring.cc.

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

◆ rDBChangeSComps()

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

Definition at line 4383 of file ring.cc.

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

◆ rDBGetSComps()

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

Definition at line 4393 of file ring.cc.

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

◆ rDBTest()

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

Definition at line 2038 of file ring.cc.

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

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

◆ rDefault() [2/4]

ring rDefault ( const coeffs  cf,
int  N,
char **  n,
int  ord_size,
rRingOrder_t ord,
int *  block0,
int *  block1,
int **  wvhdl,
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:30
@ n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:413

◆ rDefault() [4/4]

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

Definition at line 130 of file ring.cc.

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

◆ rDelete()

void rDelete ( ring  r)

unconditionally deletes fields in r

Definition at line 450 of file ring.cc.

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

◆ rEnvelope()

ring rEnvelope ( ring  R)

Definition at line 5671 of file ring.cc.

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

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

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

◆ rGetDivMask()

static unsigned long rGetDivMask ( int  bits)
static

get r->divmask depending on bits per exponent

Definition at line 4108 of file ring.cc.

4109 {
4110  unsigned long divmask = 1;
4111  int i = bits;
4112 
4113  while (i < BIT_SIZEOF_LONG)
4114  {
4115  divmask |= (((unsigned long) 1) << (unsigned long) i);
4116  i += bits;
4117  }
4118  return divmask;
4119 }

◆ rGetExpSize() [1/2]

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

Definition at line 2570 of file ring.cc.

2571 {
2572  if (bitmask == 0)
2573  {
2574  bits=16; bitmask=0xffff;
2575  }
2576  else if (bitmask <= 1L)
2577  {
2578  bits=1; bitmask = 1L;
2579  }
2580  else if (bitmask <= 3L)
2581  {
2582  bits=2; bitmask = 3L;
2583  }
2584  else if (bitmask <= 7L)
2585  {
2586  bits=3; bitmask=7L;
2587  }
2588  else if (bitmask <= 0xfL)
2589  {
2590  bits=4; bitmask=0xfL;
2591  }
2592  else if (bitmask <= 0x1fL)
2593  {
2594  bits=5; bitmask=0x1fL;
2595  }
2596  else if (bitmask <= 0x3fL)
2597  {
2598  bits=6; bitmask=0x3fL;
2599  }
2600 #if SIZEOF_LONG == 8
2601  else if (bitmask <= 0x7fL)
2602  {
2603  bits=7; bitmask=0x7fL; /* 64 bit longs only */
2604  }
2605 #endif
2606  else if (bitmask <= 0xffL)
2607  {
2608  bits=8; bitmask=0xffL;
2609  }
2610 #if SIZEOF_LONG == 8
2611  else if (bitmask <= 0x1ffL)
2612  {
2613  bits=9; bitmask=0x1ffL; /* 64 bit longs only */
2614  }
2615 #endif
2616  else if (bitmask <= 0x3ffL)
2617  {
2618  bits=10; bitmask=0x3ffL;
2619  }
2620 #if SIZEOF_LONG == 8
2621  else if (bitmask <= 0xfffL)
2622  {
2623  bits=12; bitmask=0xfff; /* 64 bit longs only */
2624  }
2625 #endif
2626  else if (bitmask <= 0xffffL)
2627  {
2628  bits=16; bitmask=0xffffL;
2629  }
2630 #if SIZEOF_LONG == 8
2631  else if (bitmask <= 0xfffffL)
2632  {
2633  bits=20; bitmask=0xfffffL; /* 64 bit longs only */
2634  }
2635  else if (bitmask <= 0xffffffffL)
2636  {
2637  bits=32; bitmask=0xffffffffL;
2638  }
2639  else if (bitmask <= 0x7fffffffffffffffL)
2640  {
2641  bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
2642  }
2643  else
2644  {
2645  bits=63; bitmask=0x7fffffffffffffffL; /* for overflow tests*/
2646  }
2647 #else
2648  else if (bitmask <= 0x7fffffff)
2649  {
2650  bits=31; bitmask=0x7fffffff; /* for overflow tests*/
2651  }
2652  else
2653  {
2654  bits=31; bitmask=0x7fffffffL; /* for overflow tests*/
2655  }
2656 #endif
2657  return bitmask;
2658 }

◆ rGetExpSize() [2/2]

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

Definition at line 2663 of file ring.cc.

2664 {
2665  bitmask =rGetExpSize(bitmask, bits);
2666  int vars_per_long=BIT_SIZEOF_LONG/bits;
2667  int bits1;
2668  loop
2669  {
2670  if (bits == BIT_SIZEOF_LONG-1)
2671  {
2672  bits = BIT_SIZEOF_LONG - 1;
2673  return LONG_MAX;
2674  }
2675  unsigned long bitmask1 =rGetExpSize(bitmask+1, bits1);
2676  int vars_per_long1=BIT_SIZEOF_LONG/bits1;
2677  if ((((N+vars_per_long-1)/vars_per_long) ==
2678  ((N+vars_per_long1-1)/vars_per_long1)))
2679  {
2680  vars_per_long=vars_per_long1;
2681  bits=bits1;
2682  bitmask=bitmask1;
2683  }
2684  else
2685  {
2686  return bitmask; /* and bits */
2687  }
2688  }
2689 }
#define loop
Definition: structs.h:75

◆ rGetISPos()

int rGetISPos ( const int  p,
const ring  r 
)

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

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

◆ rGetMaxSyzComp()

int rGetMaxSyzComp ( int  i,
const ring  r 
)

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

Definition at line 5158 of file ring.cc.

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

◆ rGetOrderType()

rOrderType_t rGetOrderType ( ring  r)

Definition at line 1840 of file ring.cc.

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

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

◆ rGetVar()

poly rGetVar ( const int  varIndex,
const ring  r 
)

Definition at line 5763 of file ring.cc.

5764 {
5765  poly p = p_ISet(1, r);
5766  p_SetExp(p, varIndex, 1, r);
5767  p_Setm(p, r);
5768  return p;
5769 }
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1297
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:486
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:231

◆ rGetWeightVec()

int64* rGetWeightVec ( const ring  r)

Definition at line 5222 of file ring.cc.

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

◆ rHas_c_Ordering()

BOOLEAN rHas_c_Ordering ( const ring  r)

Definition at line 1883 of file ring.cc.

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

◆ rHasSimpleLexOrder()

BOOLEAN rHasSimpleLexOrder ( const ring  r)

returns TRUE, if simple lp or ls ordering

Definition at line 1919 of file ring.cc.

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

◆ rHasSimpleOrder()

BOOLEAN rHasSimpleOrder ( const ring  r)

Definition at line 1887 of file ring.cc.

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

◆ rHasSimpleOrderAA()

BOOLEAN rHasSimpleOrderAA ( ring  r)

Definition at line 1962 of file ring.cc.

1963 {
1964  if (r->order[0] == ringorder_unspec) return TRUE;
1965  int blocks = rBlocks(r) - 1;
1966  assume(blocks >= 1);
1967  if (blocks == 1) return TRUE;
1968 
1969  int s = 0;
1970  while( (s < blocks) && (r->order[s] == ringorder_IS) && (r->order[blocks-1] == ringorder_IS) )
1971  {
1972  s++;
1973  blocks--;
1974  }
1975 
1976  if ((blocks - s) > 3) return FALSE;
1977 
1978 // if ((blocks > 3) || (blocks < 2)) return FALSE;
1979  if ((blocks - s) == 3)
1980  {
1981  return (((r->order[s] == ringorder_aa) && (r->order[s+1] != ringorder_M) &&
1982  ((r->order[s+2] == ringorder_c) || (r->order[s+2] == ringorder_C))) ||
1983  (((r->order[s] == ringorder_c) || (r->order[s] == ringorder_C)) &&
1984  (r->order[s+1] == ringorder_aa) && (r->order[s+2] != ringorder_M)));
1985  }
1986  else
1987  {
1988  return ((r->order[s] == ringorder_aa) && (r->order[s+1] != ringorder_M));
1989  }
1990 }

◆ rKillModified_Wp_Ring()

void rKillModified_Wp_Ring ( ring  r)

Definition at line 3069 of file ring.cc.

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

◆ rKillModifiedRing()

void rKillModifiedRing ( ring  r)

Definition at line 3059 of file ring.cc.

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

◆ rMinusVar()

ring rMinusVar ( const ring  r,
char *  v 
)

undo rPlusVar

Definition at line 5876 of file ring.cc.

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

◆ rModifyRing()

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

< How many induced ordering block do we have?

Definition at line 2698 of file ring.cc.

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

◆ rModifyRing_Simple()

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

Definition at line 2993 of file ring.cc.

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

◆ rModifyRing_Wp()

ring rModifyRing_Wp ( ring  r,
int *  weights 
)

construct Wp, C ring

Definition at line 2945 of file ring.cc.

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

◆ rNChangeSComps()

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

Definition at line 4367 of file ring.cc.

4368 {
4369  assume(r->typ[1].ord_typ == ro_syzcomp);
4370 
4371  r->typ[1].data.syzcomp.ShiftedComponents = currShiftedComponents;
4372  r->typ[1].data.syzcomp.Components = currComponents;
4373 }

◆ rNGetSComps()

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

Definition at line 4375 of file ring.cc.

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

◆ rO_Align()

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

Definition at line 2188 of file ring.cc.

2189 {
2190  // increment place to the next aligned one
2191  // (count as Exponent_t,align as longs)
2192  if (bitplace!=BITS_PER_LONG)
2193  {
2194  place++;
2195  bitplace=BITS_PER_LONG;
2196  }
2197 }

◆ rO_ISPrefix()

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

Definition at line 2456 of file ring.cc.

2458 {
2459  if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2460  rO_Align(place,bitplace);
2461  // since we add something afterwards - it's better to start with anew!?
2462 
2463  ord_struct.ord_typ = ro_isTemp;
2464  ord_struct.data.isTemp.start = place;
2465  #ifdef HAVE_OMALLOC
2466  ord_struct.data.isTemp.pVarOffset = (int *)omMemDup(v);
2467  #else
2468  ord_struct.data.isTemp.pVarOffset = (int *)omAlloc((N+1)*sizeof(int));
2469  memcpy(ord_struct.data.isTemp.pVarOffset,v,(N+1)*sizeof(int));
2470  #endif
2471  ord_struct.data.isTemp.suffixpos = -1;
2472 
2473  // We will act as rO_Syz on our own!!!
2474  // Here we allocate an exponent as a level placeholder
2475  o[place]= -1;
2476  prev_ord=-1;
2477  place++;
2478 }
ro_typ ord_typ
Definition: ring.h:220
union sro_ord::@1 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 2479 of file ring.cc.

2481 {
2482 
2483  // Let's find previous prefix:
2484  int typ_j = typ_i - 1;
2485  while(typ_j >= 0)
2486  {
2487  if( tmp_typ[typ_j].ord_typ == ro_isTemp)
2488  break;
2489  typ_j --;
2490  }
2491 
2492  assume( typ_j >= 0 );
2493 
2494  if( typ_j < 0 ) // Found NO prefix!!! :(
2495  return;
2496 
2497  assume( tmp_typ[typ_j].ord_typ == ro_isTemp );
2498 
2499  // Get saved state:
2500  const int start = tmp_typ[typ_j].data.isTemp.start;
2501  int *pVarOffset = tmp_typ[typ_j].data.isTemp.pVarOffset;
2502 
2503 /*
2504  // shift up all blocks
2505  while(typ_j < (typ_i-1))
2506  {
2507  tmp_typ[typ_j] = tmp_typ[typ_j+1];
2508  typ_j++;
2509  }
2510  typ_j = typ_i - 1; // No increment for typ_i
2511 */
2512  tmp_typ[typ_j].data.isTemp.suffixpos = typ_i;
2513 
2514  // Let's keep that dummy for now...
2515  typ_j = typ_i; // the typ to change!
2516  typ_i++; // Just for now...
2517 
2518 
2519  for( int i = 0; i <= N; i++ ) // Note [0] == component !!! No Skip?
2520  {
2521  // Was i-th variable allocated inbetween?
2522  if( v[i] != pVarOffset[i] )
2523  {
2524  pVarOffset[i] = v[i]; // Save for later...
2525  v[i] = -1; // Undo!
2526  assume( pVarOffset[i] != -1 );
2527  }
2528  else
2529  pVarOffset[i] = -1; // No change here...
2530  }
2531 
2532  if( pVarOffset[0] != -1 )
2533  pVarOffset[0] &= 0x0fff;
2534 
2535  sro_ord &ord_struct = tmp_typ[typ_j];
2536 
2537 
2538  ord_struct.ord_typ = ro_is;
2539  ord_struct.data.is.start = start;
2540  ord_struct.data.is.end = place;
2541  ord_struct.data.is.pVarOffset = pVarOffset;
2542 
2543 
2544  // What about component???
2545 // if( v[0] != -1 ) // There is a component already...???
2546 // if( o[ v[0] & 0x0fff ] == sgn )
2547 // {
2548 // pVarOffset[0] = -1; // NEVER USED Afterwards...
2549 // return;
2550 // }
2551 
2552 
2553  // Moreover: we need to allocate the module component (v[0]) here!
2554  if( v[0] == -1) // It's possible that there was module component v0 at the begining (before prefix)!
2555  {
2556  // Start with a whole long exponent
2557  if( bitplace != BITS_PER_LONG )
2558  rO_Align(place, bitplace);
2559 
2560  assume( bitplace == BITS_PER_LONG );
2561  bitplace -= BITS_PER_LONG;
2562  assume(bitplace == 0);
2563  v[0] = place | (bitplace << 24); // Never mind whether pVarOffset[0] > 0!!!
2564  o[place] = sgn; // Singnum for component ordering
2565  prev_ord = sgn;
2566  }
2567 }

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

2341 {
2342  // a block of variables v_start..v_end with lex order, ordsgn 1
2343  int k;
2344  int incr=1;
2345  if(prev_ord==-1) rO_Align(place,bitplace);
2346 
2347  if (start>end)
2348  {
2349  incr=-1;
2350  }
2351  for(k=start;;k+=incr)
2352  {
2353  bitplace-=bits;
2354  if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
2355  o[place]=1;
2356  v[k]= place | (bitplace << 24);
2357  if (k==end) break;
2358  }
2359  prev_ord=1;
2360  if (opt_var!= -1)
2361  {
2362  assume((opt_var == end+1) ||(opt_var == end-1));
2363  if((opt_var != end+1) &&(opt_var != end-1)) WarnS("hier-2");
2364  int save_bitplace=bitplace;
2365  bitplace-=bits;
2366  if (bitplace < 0)
2367  {
2368  bitplace=save_bitplace;
2369  return;
2370  }
2371  // there is enough space for the optional var
2372  v[opt_var]=place | (bitplace << 24);
2373  }
2374 }

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

2378 {
2379  // a block of variables v_start..v_end with lex order, ordsgn -1
2380  int k;
2381  int incr=1;
2382  if(prev_ord==1) rO_Align(place,bitplace);
2383 
2384  if (start>end)
2385  {
2386  incr=-1;
2387  }
2388  for(k=start;;k+=incr)
2389  {
2390  bitplace-=bits;
2391  if (bitplace < 0) { bitplace=BITS_PER_LONG-bits; place++; }
2392  o[place]=-1;
2393  v[k]=place | (bitplace << 24);
2394  if (k==end) break;
2395  }
2396  prev_ord=-1;
2397 // #if 0
2398  if (opt_var!= -1)
2399  {
2400  assume((opt_var == end+1) ||(opt_var == end-1));
2401  if((opt_var != end+1) &&(opt_var != end-1)) WarnS("hier-1");
2402  int save_bitplace=bitplace;
2403  bitplace-=bits;
2404  if (bitplace < 0)
2405  {
2406  bitplace=save_bitplace;
2407  return;
2408  }
2409  // there is enough space for the optional var
2410  v[opt_var]=place | (bitplace << 24);
2411  }
2412 // #endif
2413 }

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

2432 {
2433  // ordering is derived from component number
2434  // let's reserve one Exponent_t for it
2435  if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2436  rO_Align(place,bitplace);
2437  ord_struct.ord_typ=ro_syz;
2438  ord_struct.data.syz.place=place;
2439  ord_struct.data.syz.limit=syz_comp;
2440  if (syz_comp>0)
2441  ord_struct.data.syz.syz_index = (int*) omAlloc0((syz_comp+1)*sizeof(int));
2442  else
2443  ord_struct.data.syz.syz_index = NULL;
2444  ord_struct.data.syz.curr_index = 1;
2445  o[place]= -1;
2446  prev_ord=-1;
2447  place++;
2448 }

◆ rO_Syzcomp()

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

Definition at line 2415 of file ring.cc.

2417 {
2418  // ordering is derived from component number
2419  rO_Align(place,bitplace);
2420  ord_struct.ord_typ=ro_syzcomp;
2421  ord_struct.data.syzcomp.place=place;
2422  ord_struct.data.syzcomp.Components=NULL;
2423  ord_struct.data.syzcomp.ShiftedComponents=NULL;
2424  o[place]=1;
2425  prev_ord=1;
2426  place++;
2427  rO_Align(place,bitplace);
2428 }

◆ rO_TDegree()

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

Definition at line 2199 of file ring.cc.

2201 {
2202  // degree (aligned) of variables v_start..v_end, ordsgn 1
2203  rO_Align(place,bitplace);
2204  ord_struct.ord_typ=ro_dp;
2205  ord_struct.data.dp.start=start;
2206  ord_struct.data.dp.end=end;
2207  ord_struct.data.dp.place=place;
2208  o[place]=1;
2209  place++;
2210  rO_Align(place,bitplace);
2211 }

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

2215 {
2216  // degree (aligned) of variables v_start..v_end, ordsgn -1
2217  rO_Align(place,bitplace);
2218  ord_struct.ord_typ=ro_dp;
2219  ord_struct.data.dp.start=start;
2220  ord_struct.data.dp.end=end;
2221  ord_struct.data.dp.place=place;
2222  o[place]=-1;
2223  place++;
2224  rO_Align(place,bitplace);
2225 }

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

2229 {
2230  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2231  while((start<end) && (weights[0]==0)) { start++; weights++; }
2232  while((start<end) && (weights[end-start]==0)) { end--; }
2233  int i;
2234  int pure_tdeg=1;
2235  for(i=start;i<=end;i++)
2236  {
2237  if(weights[i-start]!=1)
2238  {
2239  pure_tdeg=0;
2240  break;
2241  }
2242  }
2243  if (pure_tdeg)
2244  {
2245  rO_TDegree(place,bitplace,start,end,o,ord_struct);
2246  return;
2247  }
2248  rO_Align(place,bitplace);
2249  ord_struct.ord_typ=ro_wp;
2250  ord_struct.data.wp.start=start;
2251  ord_struct.data.wp.end=end;
2252  ord_struct.data.wp.place=place;
2253  ord_struct.data.wp.weights=weights;
2254  o[place]=1;
2255  place++;
2256  rO_Align(place,bitplace);
2257  for(i=start;i<=end;i++)
2258  {
2259  if(weights[i-start]<0)
2260  {
2261  ord_struct.ord_typ=ro_wp_neg;
2262  break;
2263  }
2264  }
2265 }

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

2291 {
2292  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1,
2293  // reserved 2 places
2294  rO_Align(place,bitplace);
2295  ord_struct.ord_typ=ro_wp64;
2296  ord_struct.data.wp64.start=start;
2297  ord_struct.data.wp64.end=end;
2298  ord_struct.data.wp64.place=place;
2299  #ifdef HAVE_OMALLOC
2300  ord_struct.data.wp64.weights64=weights;
2301  #else
2302  int l=end-start+1;
2303  ord_struct.data.wp64.weights64=(int64*)omAlloc(l*sizeof(int64));
2304  for(int i=0;i<l;i++) ord_struct.data.wp64.weights64[i]=weights[i];
2305  #endif
2306  o[place]=1;
2307  place++;
2308  o[place]=1;
2309  place++;
2310  rO_Align(place,bitplace);
2311 }

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

2315 {
2316  // weighted degree (aligned) of variables v_start..v_end, ordsgn -1
2317  while((start<end) && (weights[0]==0)) { start++; weights++; }
2318  while((start<end) && (weights[end-start]==0)) { end--; }
2319  rO_Align(place,bitplace);
2320  ord_struct.ord_typ=ro_wp;
2321  ord_struct.data.wp.start=start;
2322  ord_struct.data.wp.end=end;
2323  ord_struct.data.wp.place=place;
2324  ord_struct.data.wp.weights=weights;
2325  o[place]=-1;
2326  place++;
2327  rO_Align(place,bitplace);
2328  int i;
2329  for(i=start;i<=end;i++)
2330  {
2331  if(weights[i-start]<0)
2332  {
2333  ord_struct.ord_typ=ro_wp_neg;
2334  break;
2335  }
2336  }
2337 }

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

2269 {
2270  assume(weights != NULL);
2271 
2272  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2273 // while((start<end) && (weights[0]==0)) { start++; weights++; }
2274 // while((start<end) && (weights[end-start]==0)) { end--; }
2275  rO_Align(place,bitplace);
2276  ord_struct.ord_typ=ro_am;
2277  ord_struct.data.am.start=start;
2278  ord_struct.data.am.end=end;
2279  ord_struct.data.am.place=place;
2280  ord_struct.data.am.weights=weights;
2281  ord_struct.data.am.weights_m = weights + (end-start+1);
2282  ord_struct.data.am.len_gen=weights[end-start+1];
2283  assume( ord_struct.data.am.weights_m[0] == ord_struct.data.am.len_gen );
2284  o[place]=1;
2285  place++;
2286  rO_Align(place,bitplace);
2287 }

◆ rOpposite()

ring rOpposite ( ring  src)

Definition at line 5281 of file ring.cc.

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

5266 {
5267  /* works for commutative/Plural; need to be changed for Letterplace */
5268  /* Letterpace: each block of vars needs to be reverted on it own */
5269  int i2=(l+1)/2;
5270  for(int j=0; j<=i2; j++)
5271  {
5272  int t=w[j];
5273  w[j]=w[l-j];
5274  w[l-j]=t;
5275  }
5276 }
const CanonicalForm & w
Definition: facAbsFact.cc:51

◆ rOptimizeLDeg()

static void rOptimizeLDeg ( ring  r)
static

Definition at line 3150 of file ring.cc.

3151 {
3152  if (r->pFDeg == p_Deg)
3153  {
3154  if (r->pLDeg == pLDeg1)
3155  r->pLDeg = pLDeg1_Deg;
3156  if (r->pLDeg == pLDeg1c)
3157  r->pLDeg = pLDeg1c_Deg;
3158  }
3159  else if (r->pFDeg == p_Totaldegree)
3160  {
3161  if (r->pLDeg == pLDeg1)
3162  r->pLDeg = pLDeg1_Totaldegree;
3163  if (r->pLDeg == pLDeg1c)
3164  r->pLDeg = pLDeg1c_Totaldegree;
3165  }
3166  else if (r->pFDeg == p_WFirstTotalDegree)
3167  {
3168  if (r->pLDeg == pLDeg1)
3169  r->pLDeg = pLDeg1_WFirstTotalDegree;
3170  if (r->pLDeg == pLDeg1c)
3171  r->pLDeg = pLDeg1c_WFirstTotalDegree;
3172  }
3173  r->pLDegOrig = r->pLDeg;
3174 }
long pLDeg1_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:975
long pLDeg1_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1038
long pLDeg1c_WFirstTotalDegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1068
long pLDeg1c_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:941
long pLDeg1(poly p, int *l, const ring r)
Definition: p_polys.cc:841
long pLDeg1_Deg(poly p, int *l, const ring r)
Definition: p_polys.cc:910
long pLDeg1c(poly p, int *l, const ring r)
Definition: p_polys.cc:877
long pLDeg1c_Totaldegree(poly p, int *l, const ring r)
Definition: p_polys.cc:1005

◆ rOrd_is_MixedDegree_Ordering()

BOOLEAN rOrd_is_MixedDegree_Ordering ( ring  r)

Definition at line 3428 of file ring.cc.

3429 {
3430  int i;
3431  poly p=p_One(r);
3432  p_SetExp(p,1,1,r);
3433  p_Setm(p,r);
3434  int vz=sign(p_FDeg(p,r));
3435  for(i=2;i<=rVar(r);i++)
3436  {
3437  p_SetExp(p,i-1,0,r);
3438  p_SetExp(p,i,1,r);
3439  p_Setm(p,r);
3440  if (sign(p_FDeg(p,r))!=vz)
3441  {
3442  p_Delete(&p,r);
3443  return TRUE;
3444  }
3445  }
3446  p_Delete(&p,r);
3447  return FALSE;
3448 }
static long p_FDeg(const poly p, const ring r)
Definition: p_polys.h:378
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:899
static int sign(int x)
Definition: ring.cc:3427

◆ rOrd_is_Totaldegree_Ordering()

BOOLEAN rOrd_is_Totaldegree_Ordering ( const ring  r)

Definition at line 2013 of file ring.cc.

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

◆ rOrd_is_WeightedDegree_Ordering()

BOOLEAN rOrd_is_WeightedDegree_Ordering ( const ring  r)

Definition at line 2027 of file ring.cc.

2028 {
2029  // Hmm.... what about Syz orderings?
2030  return ((rVar(r) > 1) &&
2031  rHasSimpleOrder(r) &&
2032  (rOrder_is_WeightedOrdering((rRingOrder_t)r->order[0]) ||
2033  rOrder_is_WeightedOrdering(( rRingOrder_t)r->order[1])));
2034 }
BOOLEAN rOrder_is_WeightedOrdering(rRingOrder_t order)
Definition: ring.cc:1947

◆ rOrd_SetCompRequiresSetm()

BOOLEAN rOrd_SetCompRequiresSetm ( const ring  r)

return TRUE if p_SetComp requires p_Setm

Definition at line 1993 of file ring.cc.

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

◆ rOrder_is_DegOrdering()

BOOLEAN rOrder_is_DegOrdering ( const rRingOrder_t  order)

Definition at line 1928 of file ring.cc.

1929 {
1930  switch(order)
1931  {
1932  case ringorder_dp:
1933  case ringorder_Dp:
1934  case ringorder_ds:
1935  case ringorder_Ds:
1936  case ringorder_Ws:
1937  case ringorder_Wp:
1938  case ringorder_ws:
1939  case ringorder_wp:
1940  return TRUE;
1941 
1942  default:
1943  return FALSE;
1944  }
1945 }

◆ rOrder_is_WeightedOrdering()

BOOLEAN rOrder_is_WeightedOrdering ( rRingOrder_t  order)

Definition at line 1947 of file ring.cc.

1948 {
1949  switch(order)
1950  {
1951  case ringorder_Ws:
1952  case ringorder_Wp:
1953  case ringorder_ws:
1954  case ringorder_wp:
1955  return TRUE;
1956 
1957  default:
1958  return FALSE;
1959  }
1960 }

◆ rOrderName()

rRingOrder_t rOrderName ( char *  ordername)

Definition at line 507 of file ring.cc.

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

◆ rOrdStr()

char* rOrdStr ( ring  r)

Definition at line 521 of file ring.cc.

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

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

◆ rPlusVar()

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

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

Definition at line 5794 of file ring.cc.

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

◆ rRealloc1()

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

Definition at line 5242 of file ring.cc.

5243 {
5244  r->order=(rRingOrder_t*)omReallocSize(r->order, size*sizeof(rRingOrder_t), (size+1)*sizeof(rRingOrder_t));
5245  r->block0=(int*)omReallocSize(r->block0, size*sizeof(int), (size+1)*sizeof(int));
5246  r->block1=(int*)omReallocSize(r->block1, size*sizeof(int), (size+1)*sizeof(int));
5247  r->wvhdl=(int **)omReallocSize(r->wvhdl,size*sizeof(int *), (size+1)*sizeof(int *));
5248  for(int k=size; k>pos; k--) r->wvhdl[k]=r->wvhdl[k-1];
5249  r->order[size]=(rRingOrder_t)0;
5250  size++;
5251  return size;
5252 }
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 4082 of file ring.cc.

4083 {
4084  int* shifts = (int*) omAlloc(r->ExpL_Size*sizeof(int));
4085  int i;
4086  // initialize shifts
4087  for (i=0;i<r->ExpL_Size;i++)
4088  shifts[i] = BIT_SIZEOF_LONG;
4089 
4090  // find minimal bit shift in each long exp entry
4091  for (i=1;i<=r->N;i++)
4092  {
4093  if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
4094  shifts[r->VarOffset[i] & 0xffffff] = r->VarOffset[i] >> 24;
4095  }
4096  // reset r->VarOffset: set the minimal shift to 0
4097  for (i=1;i<=r->N;i++)
4098  {
4099  if (shifts[r->VarOffset[i] & 0xffffff] != 0)
4100  r->VarOffset[i]
4101  = (r->VarOffset[i] & 0xffffff) |
4102  (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[i] & 0xffffff]) << 24);
4103  }
4104  omFree(shifts);
4105 }

◆ rRing_has_CompLastBlock()

BOOLEAN rRing_has_CompLastBlock ( const ring  r)

Definition at line 5185 of file ring.cc.

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

◆ rRing_ord_pure_dp()

BOOLEAN rRing_ord_pure_dp ( const ring  r)

Definition at line 5192 of file ring.cc.

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

◆ rRing_ord_pure_Dp()

BOOLEAN rRing_ord_pure_Dp ( const ring  r)

Definition at line 5202 of file ring.cc.

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

◆ rRing_ord_pure_lp()

BOOLEAN rRing_ord_pure_lp ( const ring  r)

Definition at line 5212 of file ring.cc.

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

◆ rSamePolyRep()

BOOLEAN rSamePolyRep ( ring  r1,
ring  r2 
)

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

Definition at line 1799 of file ring.cc.

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

◆ rSetDegStuff()

static void rSetDegStuff ( ring  r)
static

Definition at line 3177 of file ring.cc.

3178 {
3179  rRingOrder_t* order = r->order;
3180  int* block0 = r->block0;
3181  int* block1 = r->block1;
3182  int** wvhdl = r->wvhdl;
3183 
3184  if (order[0]==ringorder_S ||order[0]==ringorder_s || order[0]==ringorder_IS)
3185  {
3186  order++;
3187  block0++;
3188  block1++;
3189  wvhdl++;
3190  }
3191  r->LexOrder = FALSE;
3192  r->pFDeg = p_Totaldegree;
3193  r->pLDeg = (r->OrdSgn == 1 ? pLDegb : pLDeg0);
3194 
3195  /*======== ordering type is (am,_) ==================*/
3196  if (order[0]==ringorder_am)
3197  {
3198  for(int ii=block0[0];ii<=block1[0];ii++)
3199  if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
3200  r->LexOrder=FALSE;
3201  for(int ii=block0[0];ii<=block1[0];ii++)
3202  if (wvhdl[0][ii-1]==0) { r->LexOrder=TRUE;break;}
3203  if ((block0[0]==1)&&(block1[0]==r->N))
3204  {
3205  r->pFDeg = p_Deg;
3206  r->pLDeg = pLDeg1c_Deg;
3207  }
3208  else
3209  {
3210  r->pFDeg = p_WTotaldegree;
3211  r->LexOrder=TRUE;
3212  r->pLDeg = pLDeg1c_WFirstTotalDegree;
3213  }
3214  r->firstwv = wvhdl[0];
3215  }
3216  /*======== ordering type is (_,c) =========================*/
3217  else if ((order[0]==ringorder_unspec) || (order[1] == 0)
3218  ||(
3219  ((order[1]==ringorder_c)||(order[1]==ringorder_C)
3220  ||(order[1]==ringorder_S)
3221  ||(order[1]==ringorder_s))
3222  && (order[0]!=ringorder_M)
3223  && (order[2]==0))
3224  )
3225  {
3226  if (r->OrdSgn == -1) r->pLDeg = pLDeg0c;
3227  if ((order[0] == ringorder_lp)
3228  || (order[0] == ringorder_ls)
3229  || (order[0] == ringorder_rp)
3230  || (order[0] == ringorder_rs))
3231  {
3232  r->LexOrder=TRUE;
3233  r->pLDeg = pLDeg1c;
3234  r->pFDeg = p_Totaldegree;
3235  }
3236  else if ((order[0] == ringorder_a)
3237  || (order[0] == ringorder_wp)
3238  || (order[0] == ringorder_Wp))
3239  {
3240  r->pFDeg = p_WFirstTotalDegree;
3241  }
3242  else if ((order[0] == ringorder_ws)
3243  || (order[0] == ringorder_Ws))
3244  {
3245  for(int ii=block0[0];ii<=block1[0];ii++)
3246  {
3247  if (wvhdl[0][ii-1]<0) { r->MixedOrder=2;break;}
3248  }
3249  if (r->MixedOrder==0)
3250  {
3251  if ((block0[0]==1)&&(block1[0]==r->N))
3252  r->pFDeg = p_WTotaldegree;
3253  else
3254  r->pFDeg = p_WFirstTotalDegree;
3255  }
3256  else
3257  r->pFDeg = p_Totaldegree;
3258  }
3259  r->firstBlockEnds=block1[0];
3260  r->firstwv = wvhdl[0];
3261  }
3262  /*======== ordering type is (c,_) =========================*/
3263  else if (((order[0]==ringorder_c)
3264  ||(order[0]==ringorder_C)
3265  ||(order[0]==ringorder_S)
3266  ||(order[0]==ringorder_s))
3267  && (order[1]!=ringorder_M)
3268  && (order[2]==0))
3269  {
3270  if ((order[1] == ringorder_lp)
3271  || (order[1] == ringorder_ls)
3272  || (order[1] == ringorder_rp)
3273  || order[1] == ringorder_rs)
3274  {
3275  r->LexOrder=TRUE;
3276  r->pLDeg = pLDeg1c;
3277  r->pFDeg = p_Totaldegree;
3278  }
3279  r->firstBlockEnds=block1[1];
3280  if (wvhdl!=NULL) r->firstwv = wvhdl[1];
3281  if ((order[1] == ringorder_a)
3282  || (order[1] == ringorder_wp)
3283  || (order[1] == ringorder_Wp))
3284  r->pFDeg = p_WFirstTotalDegree;
3285  else if ((order[1] == ringorder_ws)
3286  || (order[1] == ringorder_Ws))
3287  {
3288  for(int ii=block0[1];ii<=block1[1];ii++)
3289  if (wvhdl[1][ii-1]<0) { r->MixedOrder=2;break;}
3290  if (r->MixedOrder==FALSE)
3291  r->pFDeg = p_WFirstTotalDegree;
3292  else
3293  r->pFDeg = p_Totaldegree;
3294  }
3295  }
3296  /*------- more than one block ----------------------*/
3297  else
3298  {
3299  if ((r->VectorOut)||(order[0]==ringorder_C)||(order[0]==ringorder_S)||(order[0]==ringorder_s))
3300  {
3301  rSetFirstWv(r, 1, order, block0, block1, wvhdl);
3302  }
3303  else
3304  rSetFirstWv(r, 0, order, block0, block1, wvhdl);
3305 
3306  if ((order[0]!=ringorder_c)
3307  && (order[0]!=ringorder_C)
3308  && (order[0]!=ringorder_S)
3309  && (order[0]!=ringorder_s))
3310  {
3311  r->pLDeg = pLDeg1c;
3312  }
3313  else
3314  {
3315  r->pLDeg = pLDeg1;
3316  }
3317  r->pFDeg = p_WTotaldegree; // may be improved: p_Totaldegree for lp/dp/ls/.. blocks
3318  }
3319 
3322  {
3323  if(r->MixedOrder==FALSE)
3324  r->pFDeg = p_Deg;
3325  else
3326  r->pFDeg = p_Totaldegree;
3327  }
3328 
3329  if( rGetISPos(0, r) != -1 ) // Are there Schreyer induced blocks?
3330  {
3331 #ifndef SING_NDEBUG
3332  assume( r->pFDeg == p_Deg || r->pFDeg == p_WTotaldegree || r->pFDeg == p_Totaldegree);
3333 #endif
3334 
3335  r->pLDeg = pLDeg1; // ?
3336  }
3337 
3338  r->pFDegOrig = r->pFDeg;
3339  // NOTE: this leads to wrong ecart during std
3340  // in Old/sre.tst
3341  rOptimizeLDeg(r); // also sets r->pLDegOrig
3342 }
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
long pLDegb(poly p, int *l, const ring r)
Definition: p_polys.cc:811
long pLDeg0c(poly p, int *l, const ring r)
Definition: p_polys.cc:770
long pLDeg0(poly p, int *l, const ring r)
Definition: p_polys.cc:739
int rGetISPos(const int p, const ring r)
Finds p^th IS ordering, and returns its position in r->typ[] returns -1 if something went wrong!...
Definition: ring.cc:5000
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
Definition: ring.cc:2013
static void rSetFirstWv(ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
Definition: ring.cc:3118

◆ rSetFirstWv()

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

Definition at line 3118 of file ring.cc.

3119 {
3120  // cheat for ringorder_aa
3121  if (order[i] == ringorder_aa)
3122  i++;
3123  if(block1[i]!=r->N) r->LexOrder=TRUE;
3124  r->firstBlockEnds=block1[i];
3125  r->firstwv = wvhdl[i];
3126  if ((order[i]== ringorder_ws)
3127  || (order[i]==ringorder_Ws)
3128  || (order[i]== ringorder_wp)
3129  || (order[i]==ringorder_Wp)
3130  || (order[i]== ringorder_a)
3131  /*|| (order[i]==ringorder_A)*/)
3132  {
3133  int j;
3134  for(j=block1[i]-block0[i];j>=0;j--)
3135  {
3136  if (r->firstwv[j]==0) r->LexOrder=TRUE;
3137  }
3138  }
3139  else if (order[i]==ringorder_a64)
3140  {
3141  int j;
3142  int64 *w=rGetWeightVec(r);
3143  for(j=block1[i]-block0[i];j>=0;j--)
3144  {
3145  if (w[j]==0) r->LexOrder=TRUE;
3146  }
3147  }
3148 }
int64 * rGetWeightVec(const ring r)
Definition: ring.cc:5222

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

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

3348 {
3349  int i,l;
3350  if (r->typ!=NULL)
3351  {
3352  l=0;
3353  for(i=0;i<r->OrdSize;i++)
3354  {
3355  if((r->typ[i].ord_typ==ro_wp_neg)
3356  ||(r->typ[i].ord_typ==ro_am))
3357  l++;
3358  }
3359  if (l>0)
3360  {
3361  r->NegWeightL_Size=l;
3362  r->NegWeightL_Offset=(int *) omAlloc(l*sizeof(int));
3363  l=0;
3364  for(i=0;i<r->OrdSize;i++)
3365  {
3366  if(r->typ[i].ord_typ==ro_wp_neg)
3367  {
3368  r->NegWeightL_Offset[l]=r->typ[i].data.wp.place;
3369  l++;
3370  }
3371  else if(r->typ[i].ord_typ==ro_am)
3372  {
3373  r->NegWeightL_Offset[l]=r->typ[i].data.am.place;
3374  l++;
3375  }
3376  }
3377  return;
3378  }
3379  }
3380  r->NegWeightL_Size = 0;
3381  r->NegWeightL_Offset = NULL;
3382 }

◆ rSetOption()

static void rSetOption ( ring  r)
static

Definition at line 3384 of file ring.cc.

3385 {
3386  // set redthrough
3387  if (!TEST_OPT_OLDSTD && r->OrdSgn == 1 && ! r->LexOrder)
3388  r->options |= Sy_bit(OPT_REDTHROUGH);
3389  else
3390  r->options &= ~Sy_bit(OPT_REDTHROUGH);
3391 
3392  // set intStrategy
3393  if ( (r->cf->extRing!=NULL)
3394  || rField_is_Q(r)
3395  || rField_is_Ring(r)
3396  )
3397  r->options |= Sy_bit(OPT_INTSTRATEGY);
3398  else
3399  r->options &= ~Sy_bit(OPT_INTSTRATEGY);
3400 
3401  // set redTail
3402  if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=NULL))
3403  r->options &= ~Sy_bit(OPT_REDTAIL);
3404  else
3405  r->options |= Sy_bit(OPT_REDTAIL);
3406 }
#define OPT_INTSTRATEGY
Definition: options.h:93
#define OPT_REDTAIL
Definition: options.h:92
#define TEST_OPT_OLDSTD
Definition: options.h:124
#define OPT_REDTHROUGH
Definition: options.h:83
#define Sy_bit(x)
Definition: options.h:31
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:506
#define rField_is_Ring(R)
Definition: ring.h:485

◆ rSetOutParams()

static void rSetOutParams ( ring  r)
static

Definition at line 3080 of file ring.cc.

3081 {
3082  r->VectorOut = (r->order[0] == ringorder_c);
3083  if (rIsNCRing(r))
3084  r->CanShortOut=FALSE;
3085  else
3086  {
3087  r->CanShortOut = TRUE;
3088  int i;
3089  if (rParameter(r)!=NULL)
3090  {
3091  for (i=0;i<rPar(r);i++)
3092  {
3093  if(strlen(rParameter(r)[i])>1)
3094  {
3095  r->CanShortOut=FALSE;
3096  break;
3097  }
3098  }
3099  }
3100  if (r->CanShortOut)
3101  {
3102  int N = r->N;
3103  for (i=(N-1);i>=0;i--)
3104  {
3105  if(r->names[i] != NULL && strlen(r->names[i])>1)
3106  {
3107  r->CanShortOut=FALSE;
3108  break;
3109  }
3110  }
3111  }
3112  }
3113  r->ShortOut = r->CanShortOut;
3114 
3115  assume( !( !r->CanShortOut && r->ShortOut ) );
3116 }
static BOOLEAN rIsNCRing(const ring r)
Definition: ring.h:421

◆ rSetSyzComp()

void rSetSyzComp ( int  k,
const ring  r 
)

Definition at line 5086 of file ring.cc.

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

◆ rSetVarL()

static void rSetVarL ( ring  r)
static

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

Definition at line 4027 of file ring.cc.

4028 {
4029  int min = MAX_INT_VAL, min_j = -1;
4030  int* VarL_Number = (int*) omAlloc0(r->ExpL_Size*sizeof(int));
4031 
4032  int i,j;
4033 
4034  // count how often a var long is occupied by an exponent
4035  for (i=1; i<=r->N; i++)
4036  {
4037  VarL_Number[r->VarOffset[i] & 0xffffff]++;
4038  }
4039 
4040  // determine how many and min
4041  for (i=0, j=0; i<r->ExpL_Size; i++)
4042  {
4043  if (VarL_Number[i] != 0)
4044  {
4045  if (min > VarL_Number[i])
4046  {
4047  min = VarL_Number[i];
4048  min_j = j;
4049  }
4050  j++;
4051  }
4052  }
4053 
4054  r->VarL_Size = j; // number of long with exp. entries in
4055  // in p->exp
4056  r->VarL_Offset = (int*) omAlloc(r->VarL_Size*sizeof(int));
4057  r->VarL_LowIndex = 0;
4058 
4059  // set VarL_Offset
4060  for (i=0, j=0; i<r->ExpL_Size; i++)
4061  {
4062  if (VarL_Number[i] != 0)
4063  {
4064  r->VarL_Offset[j] = i;
4065  if (j > 0 && r->VarL_Offset[j-1] != r->VarL_Offset[j] - 1)
4066  r->VarL_LowIndex = -1;
4067  j++;
4068  }
4069  }
4070  if (r->VarL_LowIndex >= 0)
4071  r->VarL_LowIndex = r->VarL_Offset[0];
4072 
4073  if (min_j != 0)
4074  {
4075  j = r->VarL_Offset[min_j];
4076  r->VarL_Offset[min_j] = r->VarL_Offset[0];
4077  r->VarL_Offset[0] = j;
4078  }
4079  omFree(VarL_Number);
4080 }
static int min(int a, int b)
Definition: fast_mult.cc:268

◆ rSetWeightVec()

void rSetWeightVec ( ring  r,
int64 wv 
)

Definition at line 5232 of file ring.cc.

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

◆ rSimpleOrdStr()

const char* rSimpleOrdStr ( int  ord)

Definition at line 77 of file ring.cc.

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

◆ rString()

char* rString ( ring  r)

Definition at line 673 of file ring.cc.

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

◆ rSum()

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

Definition at line 1402 of file ring.cc.

1403 {
1404  if ((r1==NULL)||(r2==NULL)
1405  ||(r1->cf==NULL)||(r2->cf==NULL))
1406  return -1;
1407  if (r1==r2)
1408  {
1409  sum=r1;
1410  rIncRefCnt(r1);
1411  return 0;
1412  }
1413  return rSumInternal(r1,r2,sum,TRUE,FALSE);
1414 }
int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering,...
Definition: ring.cc:749
static ring rIncRefCnt(ring r)
Definition: ring.h:837

◆ rSumInternal()

int rSumInternal ( ring  r1,
ring  r2,
ring &  sum,
BOOLEAN  vartest,
BOOLEAN  dp_dp 
)

returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering, 1: dp,dp, 2: aa(...),dp vartest: check for name conflicts

Definition at line 749 of file ring.cc.

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

◆ rTypeOfMatrixOrder()

int rTypeOfMatrixOrder ( const intvec order)

Definition at line 185 of file ring.cc.

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

◆ rUnComplete()

void rUnComplete ( ring  r)

Definition at line 3965 of file ring.cc.

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

◆ rVarStr()

char* rVarStr ( ring  r)

Definition at line 623 of file ring.cc.

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

◆ rWrite()

void rWrite ( ring  r,
BOOLEAN  details 
)

Definition at line 226 of file ring.cc.

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

◆ sign()

static int sign ( int  x)
inlinestatic

Definition at line 3427 of file ring.cc.

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

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 5082 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.