My Project
Loading...
Searching...
No Matches
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:873
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:1473
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 {
3422 si_opt_1 &= ~ TEST_RINGDEP_OPTS;
3423 si_opt_1 |= r->options;
3424 }
3425}
VAR unsigned si_opt_1
Definition: options.c:5

◆ r_IsRingVar()

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

Definition at line 212 of file ring.cc.

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

◆ 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));
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);
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);
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 "" )
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:4512
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
Definition: ring.cc:1799
#define IDELEMS(i)
Definition: simpleideals.h:23

◆ 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 {
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
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 {
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:4130
#define rOppVar(R, I)
Definition: ring.cc:5278
const char * rSimpleOrdStr(int ord)
Definition: ring.cc:77
static void rOppWeight(int *w, int l)
Definition: ring.cc:5265
static int rRealloc1(ring r, int size, int pos)
Definition: ring.cc:5242
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:599
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) &&
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}
#define StringAppend
Definition: emacs.cc:79
for(j=0;j< factors.length();j++)
Definition: facHensel.cc:129
const int MAX_INT_VAL
Definition: mylimits.h:12
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
char * StringEndS()
Definition: reporter.cc:151

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

◆ rSum()

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

Definition at line 1402 of file ring.cc.

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

◆ rSumInternal()

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

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

Definition at line 749 of file ring.cc.

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

◆ rTypeOfMatrixOrder()

int rTypeOfMatrixOrder ( const intvec order)

Definition at line 185 of file ring.cc.

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

◆ rUnComplete()

void rUnComplete ( ring  r)

Definition at line 3965 of file ring.cc.

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

◆ 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:827
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.