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 charchar_ptr
 

Functions

const charrSimpleOrdStr (int ord)
 
void rDelete (ring r)
 unconditionally deletes fields in r
 
static void rSetVarL (ring r)
 set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
 
static unsigned long rGetDivMask (int bits)
 get r->divmask depending on bits per exponent
 
static void rRightAdjustVarOffset (ring r)
 right-adjust r->VarOffset
 
static void rOptimizeLDeg (ring r)
 
ring rDefault (const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
 
ring rDefault (int ch, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl)
 
ring rDefault (const coeffs cf, int N, char **n, const rRingOrder_t o)
 
ring rDefault (int ch, int N, char **n)
 
BOOLEAN rCheckIV (const intvec *iv)
 
int rTypeOfMatrixOrder (const intvec *order)
 
int r_IsRingVar (const char *n, char **names, int N)
 
void rWrite (ring r, BOOLEAN details)
 
rRingOrder_t rOrderName (char *ordername)
 
charrOrdStr (ring r)
 
charrVarStr (ring r)
 
charrCharStr (const ring r)
 TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
 
charrParStr (ring r)
 
charrString (ring r)
 
int rChar (ring r)
 
ring nc_rCreateNCcomm_rCopy (ring r)
 
int rSumInternal (ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp)
 returns -1 for not compatible, 1 for compatible (and sum) dp_dp:0: block ordering, 1: dp,dp, 2: aa(...),dp vartest: check for name conflicts
 
int rSum (ring r1, ring r2, ring &sum)
 
ring rCopy0 (const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
 
ring rCopy0AndAddA (const ring r, int64vec *wv64, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
 
ring rCopy (ring r)
 
BOOLEAN rEqual (ring r1, ring r2, BOOLEAN qr)
 returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise, if qr == 1, then qrideal equality is tested, as well
 
BOOLEAN rSamePolyRep (ring r1, ring r2)
 returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analogue to rEqual but not so strict
 
rOrderType_t rGetOrderType (ring r)
 
BOOLEAN rHas_c_Ordering (const ring r)
 
BOOLEAN rHasSimpleOrder (const ring r)
 
BOOLEAN rHasSimpleLexOrder (const ring r)
 returns TRUE, if simple lp or ls ordering
 
BOOLEAN rOrder_is_DegOrdering (const rRingOrder_t order)
 
BOOLEAN rOrder_is_WeightedOrdering (rRingOrder_t order)
 
BOOLEAN rHasSimpleOrderAA (ring r)
 
BOOLEAN rOrd_SetCompRequiresSetm (const ring r)
 return TRUE if p_SetComp requires p_Setm
 
BOOLEAN rOrd_is_Totaldegree_Ordering (const ring r)
 
BOOLEAN rOrd_is_dp (const ring r)
 
BOOLEAN rOrd_is_WeightedDegree_Ordering (const ring r)
 
BOOLEAN rDBTest (ring r, const char *fn, const int l)
 
static void rO_Align (int &place, int &bitplace)
 
static void rO_TDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
 
static void rO_TDegree_neg (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct)
 
static void rO_WDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
 
static void rO_WMDegree (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
 
static void rO_WDegree64 (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int64 *weights)
 
static void rO_WDegree_neg (int &place, int &bitplace, int start, int end, long *o, sro_ord &ord_struct, int *weights)
 
static void rO_LexVars (int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
 
static void rO_LexVars_neg (int &place, int &bitplace, int start, int end, int &prev_ord, long *o, int *v, int bits, int opt_var)
 
static void rO_Syzcomp (int &place, int &bitplace, int &prev_ord, long *o, sro_ord &ord_struct)
 
static void rO_Syz (int &place, int &bitplace, int &prev_ord, int syz_comp, long *o, sro_ord &ord_struct)
 
static void rO_ISPrefix (int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord &ord_struct)
 
static void rO_ISSuffix (int &place, int &bitplace, int &prev_ord, long *o, int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
 
static unsigned long rGetExpSize (unsigned long bitmask, int &bits)
 
unsigned long rGetExpSize (unsigned long bitmask, int &bits, int N)
 
ring rModifyRing (ring r, BOOLEAN omit_degree, BOOLEAN try_omit_comp, unsigned long exp_limit)
 
ring rModifyRing_Wp (ring r, int *weights)
 construct Wp, C ring
 
ring rModifyRing_Simple (ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
 
void rKillModifiedRing (ring r)
 
void rKillModified_Wp_Ring (ring r)
 
static void rSetOutParams (ring r)
 
static void rSetFirstWv (ring r, int i, rRingOrder_t *order, int *block0, int *block1, int **wvhdl)
 
static void rSetDegStuff (ring r)
 
static void rSetNegWeight (ring r)
 
static void rSetOption (ring r)
 
static void rCheckOrdSgn (ring r, int i)
 
void p_SetGlobals (const ring r, BOOLEAN complete)
 set all properties of a new ring - also called by rComplete
 
static int sign (int x)
 
BOOLEAN rOrd_is_MixedDegree_Ordering (ring r)
 
BOOLEAN rComplete (ring r, int force)
 this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffset), unless they already exist with force == 1, new fields are always created (overwritten), even if they exist
 
void rUnComplete (ring r)
 
void rDebugPrint (const ring r)
 
void p_DebugPrint (poly p, const ring r)
 
static void m_DebugPrint (const poly p, const ring R)
 debug-print monomial poly/vector p, assuming that it lives in the ring R
 
static void rNChangeSComps (int *currComponents, long *currShiftedComponents, ring r)
 
static void rNGetSComps (int **currComponents, long **currShiftedComponents, ring r)
 
static void rDBChangeSComps (int *currComponents, long *currShiftedComponents, int length, ring r)
 
static void rDBGetSComps (int **currComponents, long **currShiftedComponents, int *length, ring r)
 
void rChangeSComps (int *currComponents, long *currShiftedComponents, int length, ring r)
 
void rGetSComps (int **currComponents, long **currShiftedComponents, int *length, ring r)
 
ring rAssure_SyzOrder (const ring r, BOOLEAN complete)
 
ring rAssure_SyzComp (const ring r, BOOLEAN complete)
 
ring rAssure_TDeg (ring r, int &pos)
 
ring rAssure_HasComp (const ring r)
 
ring rAssure_CompLastBlock (ring r, BOOLEAN complete)
 makes sure that c/C ordering is last ordering
 
ring rAssure_SyzComp_CompLastBlock (const ring r)
 makes sure that c/C ordering is last ordering and SyzIndex is first
 
static ring rAssure_Global (rRingOrder_t b1, rRingOrder_t b2, const ring r)
 
ring rAssure_Wp_C (const ring r, intvec *w)
 
ring rAssure_InducedSchreyerOrdering (const ring r, BOOLEAN complete, int sgn)
 
ring rAssure_dp_S (const ring r)
 
ring rAssure_dp_C (const ring r)
 
ring rAssure_Dp_C (const ring r)
 
ring rAssure_C_dp (const ring r)
 
ring rAssure_c_dp (const ring r)
 
int rGetISPos (const int p, const ring r)
 Finds p^th IS ordering, and returns its position in r->typ[] returns -1 if something went wrong! p - starts with 0!
 
BOOLEAN rSetISReference (const ring r, const ideal F, const int i, const int p)
 Changes r by setting induced ordering parameters: limit and reference leading terms F belong to r, we will DO a copy! We will use it AS IS! returns true is everything was allright!
 
void rSetSyzComp (int k, const ring r)
 
int rGetMaxSyzComp (int i, const ring r)
 return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
 
BOOLEAN rRing_has_CompLastBlock (const ring r)
 
BOOLEAN rRing_ord_pure_dp (const ring r)
 
BOOLEAN rRing_ord_pure_Dp (const ring r)
 
BOOLEAN rRing_ord_pure_lp (const ring r)
 
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...
 
ring rPlusVar (const ring r, char *v, int left)
 K[x],"y" -> K[x,y] resp. K[y,x].
 
ring rMinusVar (const ring r, char *v)
 undo rPlusVar
 

Variables

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

Macro Definition Documentation

◆ BITS_PER_LONG

#define BITS_PER_LONG   8*SIZEOF_LONG

Definition at line 40 of file ring.cc.

◆ MYTEST

#define MYTEST   0

Definition at line 2462 of file ring.cc.

◆ pFDeg_CASE

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

◆ rOppVar

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

Definition at line 5339 of file ring.cc.

Typedef Documentation

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

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

◆ n_IsParam()

int n_IsParam ( const number m,
const ring r )

TODO: rewrite somehow...

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

Definition at line 5834 of file ring.cc.

5835{
5836 assume(r != NULL);
5837 const coeffs C = r->cf;
5838 assume(C != NULL);
5839
5841
5843
5844 if(( _filed_type == n_algExt )||( _filed_type == n_polyExt ))
5845 return naIsParam(m, C);
5846
5847 if( _filed_type == n_transExt )
5848 return ntIsParam(m, C);
5849
5850 Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C));
5851
5852 return 0;
5853}
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 5746 of file ring.cc.

5751{
5752// NOTE: Originally used only by idElimination to transfer NC structure to dest
5753// ring created by dirty hack (without nc_CallPlural)
5754 rTest(src);
5755
5756 assume(!rIsPluralRing(dest)); // destination must be a newly constructed commutative ring
5757
5758 if (!rIsPluralRing(src))
5759 {
5760 return FALSE;
5761 }
5762
5763 const int N = dest->N;
5764
5765 assume(src->N == N);
5766
5767// ring save = currRing;
5768
5769// if (dest != save)
5770// rChangeCurrRing(dest);
5771
5772 const ring srcBase = src;
5773
5774 assume( n_SetMap(srcBase->cf,dest->cf) == n_SetMap(dest->cf,dest->cf) ); // currRing is important here!
5775
5776 matrix C = mpNew(N,N); // ring independent
5777 matrix D = mpNew(N,N);
5778
5779 matrix C0 = src->GetNC()->C;
5780 matrix D0 = src->GetNC()->D;
5781
5782 // map C and D into dest
5783 for (int i = 1; i < N; i++)
5784 {
5785 for (int j = i + 1; j <= N; j++)
5786 {
5787 const number n = n_Copy(p_GetCoeff(MATELEM(C0,i,j), srcBase), srcBase->cf); // src, mapping for coeffs into currRing = dest!
5788 const poly p = p_NSet(n, dest);
5789 MATELEM(C,i,j) = p;
5790 if (MATELEM(D0,i,j) != NULL)
5791 MATELEM(D,i,j) = prCopyR(MATELEM(D0,i,j), srcBase, dest); // ?
5792 }
5793 }
5794 /* One must test C and D _only_ in r->GetNC()->basering!!! not in r!!! */
5795
5796 id_Test((ideal)C, dest);
5797 id_Test((ideal)D, dest);
5798
5799 if (nc_CallPlural(C, D, NULL, NULL, dest, bSetupQuotient, false, true, dest)) // also takes care about quotient ideal
5800 {
5801 //WarnS("Error transferring non-commutative structure");
5802 // error message should be in the interpreter interface
5803
5804 mp_Delete(&C, dest);
5805 mp_Delete(&D, dest);
5806
5807// if (currRing != save)
5808// rChangeCurrRing(save);
5809
5810 return TRUE;
5811 }
5812
5813// mp_Delete(&C, dest); // used by nc_CallPlural!
5814// mp_Delete(&D, dest);
5815
5816// if (dest != save)
5817// rChangeCurrRing(save);
5818
5819 assume(rIsPluralRing(dest));
5820 return FALSE;
5821}
#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,...
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:785
#define id_Test(A, lR)

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

4337{
4338 int i,j;
4339 p_Write(p,r);
4340 j=2;
4341 while(p!=NULL)
4342 {
4343 Print("\nexp[0..%d]\n",r->ExpL_Size-1);
4344 for(i=0;i<r->ExpL_Size;i++)
4345 Print("%ld ",p->exp[i]);
4346 PrintLn();
4347 Print("v0:%ld ",p_GetComp(p, r));
4348 for(i=1;i<=r->N;i++) Print(" v%d:%ld",i,p_GetExp(p,i, r));
4349 PrintLn();
4350 pIter(p);
4351 j--;
4352 if (j==0) { PrintS("...\n"); break; }
4353 }
4354}
#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 3424 of file ring.cc.

3425{
3426// // // if (r->ppNoether!=NULL) p_Delete(&r->ppNoether,r); // ???
3427
3428 r->pLexOrder=r->LexOrder;
3429 if (complete)
3430 {
3432 si_opt_1 |= r->options;
3433 }
3434}
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 5046 of file ring.cc.

5047{
5049}
static ring rAssure_Global(rRingOrder_t b1, rRingOrder_t b2, const ring r)
Definition ring.cc:4813
@ 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 5051 of file ring.cc.

5052{
5054}
@ 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 4703 of file ring.cc.

4704{
4705 int last_block = rBlocks(r) - 2;
4706 if (r->order[last_block] != ringorder_c &&
4707 r->order[last_block] != ringorder_C)
4708 {
4709 int c_pos = 0;
4710 int i;
4711
4712 for (i=0; i< last_block; i++)
4713 {
4714 if (r->order[i] == ringorder_c || r->order[i] == ringorder_C)
4715 {
4716 c_pos = i;
4717 break;
4718 }
4719 }
4720 if (c_pos != -1)
4721 {
4722 ring new_r = rCopy0(r, FALSE, TRUE);
4723 for (i=c_pos+1; i<=last_block; i++)
4724 {
4725 new_r->order[i-1] = new_r->order[i];
4726 new_r->block0[i-1] = new_r->block0[i];
4727 new_r->block1[i-1] = new_r->block1[i];
4728 new_r->wvhdl[i-1] = new_r->wvhdl[i];
4729 }
4730 new_r->order[last_block] = r->order[c_pos];
4731 new_r->block0[last_block] = r->block0[c_pos];
4732 new_r->block1[last_block] = r->block1[c_pos];
4733 new_r->wvhdl[last_block] = r->wvhdl[c_pos];
4734 if (complete)
4735 {
4736 rComplete(new_r, 1);
4737
4738#ifdef HAVE_PLURAL
4739 if (rIsPluralRing(r))
4740 {
4741 if ( nc_rComplete(r, new_r, false) ) // no qideal!
4742 {
4743#ifndef SING_NDEBUG
4744 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4745#endif
4746 }
4747 }
4749#endif
4750 }
4751 return new_r;
4752 }
4753 }
4754 return r;
4755}
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:3459
BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient)
Definition ring.cc:5746
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 5036 of file ring.cc.

5037{
5039}

◆ rAssure_Dp_C()

ring rAssure_Dp_C ( const ring r)

Definition at line 5041 of file ring.cc.

5042{
5044}
@ ringorder_Dp
Definition ring.h:80

◆ rAssure_dp_S()

ring rAssure_dp_S ( const ring r)

Definition at line 5031 of file ring.cc.

5032{
5034}
@ 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 4813 of file ring.cc.

4814{
4815 int r_blocks = rBlocks(r);
4816
4817 assume(b1 == ringorder_c || b1 == ringorder_C ||
4818 b2 == ringorder_c || b2 == ringorder_C ||
4819 b2 == ringorder_S);
4820 if ((r_blocks == 3) &&
4821 (r->order[0] == b1) &&
4822 (r->order[1] == b2) &&
4823 (r->order[2] == 0))
4824 return r;
4825 ring res = rCopy0(r, FALSE, FALSE);
4826 res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
4827 res->block0 = (int*)omAlloc0(3*sizeof(int));
4828 res->block1 = (int*)omAlloc0(3*sizeof(int));
4829 res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
4830 res->order[0] = b1;
4831 res->order[1] = b2;
4832 if (b1 == ringorder_c || b1 == ringorder_C)
4833 {
4834 res->block0[1] = 1;
4835 res->block1[1] = r->N;
4836 }
4837 else
4838 {
4839 res->block0[0] = 1;
4840 res->block1[0] = r->N;
4841 }
4842 rComplete(res, 1);
4843 if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4844#ifdef HAVE_PLURAL
4845 if (rIsPluralRing(r))
4846 {
4847 if ( nc_rComplete(r, res, false) ) // no qideal!
4848 {
4849#ifndef SING_NDEBUG
4850 WarnS("error in nc_rComplete");
4851#endif
4852 }
4853 }
4854#endif
4855// rChangeCurrRing(res);
4856 return res;
4857}
CanonicalForm res
Definition facAbsFact.cc:60
#define omAlloc0(size)
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 4634 of file ring.cc.

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

4907{ // TODO: ???? Add leading Syz-comp ordering here...????
4908
4909#if MYTEST
4910 Print("rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
4911 rWrite(r);
4912#ifdef RDEBUG
4913 rDebugPrint(r);
4914#endif
4915 PrintLn();
4916#endif
4917 assume((sgn == 1) || (sgn == -1));
4918
4919 ring res=rCopy0(r, FALSE, FALSE); // No qideal & ordering copy.
4920
4921 int n = rBlocks(r); // Including trailing zero!
4922
4923 // Create 2 more blocks for prefix/suffix:
4924 res->order=(rRingOrder_t *)omAlloc0((n+2)*sizeof(rRingOrder_t)); // 0 .. n+1
4925 res->block0=(int *)omAlloc0((n+2)*sizeof(int));
4926 res->block1=(int *)omAlloc0((n+2)*sizeof(int));
4927 int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
4928
4929 // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
4930 // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
4931
4932 // new 1st block
4933 int j = 0;
4934 res->order[j] = ringorder_IS; // Prefix
4935 res->block0[j] = res->block1[j] = 0;
4936 // wvhdl[j] = NULL;
4937 j++;
4938
4939 for(int i = 0; (i <= n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
4940 {
4941 res->order [j] = r->order [i];
4942 res->block0[j] = r->block0[i];
4943 res->block1[j] = r->block1[i];
4944
4945 if (r->wvhdl[i] != NULL)
4946 {
4947 #ifdef HAVE_OMALLOC
4948 wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
4949 #else
4950 {
4951 int l=(r->block1[i]-r->block0[i]+1);
4952 if (r->order[i]==ringorder_a64) l*=2;
4953 else if (r->order[i]==ringorder_M) l=l*l;
4954 else if (r->order[i]==ringorder_am)
4955 {
4956 l+=r->wvhdl[i][r->block1[i]-r->block0[i]+1]+1;
4957 }
4958 wvhdl[j]=(int*)omalloc(l*sizeof(int));
4959 memcpy(wvhdl[j],r->wvhdl[i],l*sizeof(int));
4960 }
4961 #endif
4962 } // else wvhdl[j] = NULL;
4963 }
4964
4965 // new last block
4966 res->order [j] = ringorder_IS; // Suffix
4967 res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
4968 // wvhdl[j] = NULL;
4969 j++;
4970
4971 // res->order [j] = 0; // The End!
4972 res->wvhdl = wvhdl;
4973
4974 // j == the last zero block now!
4975 assume(j == (n+1));
4976 assume(res->order[0]==ringorder_IS);
4977 assume(res->order[j-1]==ringorder_IS);
4978 assume(res->order[j]==0);
4979
4980
4981 if (complete)
4982 {
4983 rComplete(res, 1);
4984
4985#ifdef HAVE_PLURAL
4986 if (rIsPluralRing(r))
4987 {
4988 if ( nc_rComplete(r, res, false) ) // no qideal!
4989 {
4990#ifndef SING_NDEBUG
4991 WarnS("error in nc_rComplete"); // cleanup?// rDelete(res);// return r; // just go on..
4992#endif
4993 }
4994 }
4996#endif
4997
4998
4999#ifdef HAVE_PLURAL
5000 ring old_ring = r;
5001#endif
5002
5003 if (r->qideal!=NULL)
5004 {
5005 res->qideal= idrCopyR_NoSort(r->qideal, r, res);
5006
5007 assume(id_RankFreeModule(res->qideal, res) == 0);
5008
5009#ifdef HAVE_PLURAL
5010 if( rIsPluralRing(res) )
5011 if( nc_SetupQuotient(res, r, true) )
5012 {
5013// WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
5014 }
5015
5016#endif
5017 assume(id_RankFreeModule(res->qideal, res) == 0);
5018 }
5019
5020#ifdef HAVE_PLURAL
5021 assume((res->qideal==NULL) == (old_ring->qideal==NULL));
5025#endif
5026 }
5027
5028 return res;
5029}
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)
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:4131
@ 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 4444 of file ring.cc.

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

4759{
4760 rTest(r);
4761
4762 ring new_r_1 = rAssure_CompLastBlock(r, FALSE); // due to this FALSE - no completion!
4763 ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
4764
4765 if (new_r == r)
4766 return r;
4767
4768 ring old_r = r;
4769 if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
4770
4772#ifdef HAVE_PLURAL
4773 if (rIsPluralRing(old_r))
4774 {
4775 if ( nc_rComplete(old_r, new_r, false) ) // no qideal!
4776 {
4777# ifndef SING_NDEBUG
4778 WarnS("error in nc_rComplete"); // cleanup? rDelete(res); return r; // just go on...?
4779# endif
4780 }
4781 }
4782#endif
4783
4784///? rChangeCurrRing(new_r);
4785 if (old_r->qideal != NULL)
4786 {
4787 new_r->qideal = idrCopyR(old_r->qideal, old_r, new_r);
4788 }
4789
4790#ifdef HAVE_PLURAL
4791 if( rIsPluralRing(old_r) )
4792 if( nc_SetupQuotient(new_r, old_r, true) )
4793 {
4794#ifndef SING_NDEBUG
4795 WarnS("error in nc_SetupQuotient"); // cleanup? rDelete(res); return r; // just go on...?
4796#endif
4797 }
4798#endif
4799
4800#ifdef HAVE_PLURAL
4801 assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
4805#endif
4806
4807 rTest(new_r);
4808 rTest(old_r);
4809 return new_r;
4810}
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:4444
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:4703

◆ rAssure_SyzOrder()

ring rAssure_SyzOrder ( const ring r,
BOOLEAN complete )

Definition at line 4439 of file ring.cc.

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

◆ rAssure_TDeg()

ring rAssure_TDeg ( ring r,
int & pos )

Definition at line 4536 of file ring.cc.

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

◆ rAssure_Wp_C()

ring rAssure_Wp_C ( const ring r,
intvec * w )

Definition at line 4859 of file ring.cc.

4860{
4861 int r_blocks = rBlocks(r);
4862
4863 if ((r_blocks == 3) &&
4864 (r->order[0] == ringorder_Wp) &&
4865 (r->order[1] == ringorder_C) &&
4866 (r->order[2] == 0))
4867 {
4868 BOOLEAN ok=TRUE;
4869 for(int i=0;i<r->N;i++)
4870 {
4871 if ((*w)[i]!=r->wvhdl[0][i]) { ok=FALSE;break;}
4872 }
4873 if (ok) return r;
4874 }
4875 ring res = rCopy0(r, FALSE, FALSE);
4876 res->order = (rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
4877 res->block0 = (int*)omAlloc0(3*sizeof(int));
4878 res->block1 = (int*)omAlloc0(3*sizeof(int));
4879 res->wvhdl = (int**)omAlloc0(3*sizeof(int*));
4880 res->order[0] = ringorder_Wp;
4881 res->order[1] = ringorder_C;
4882 res->block0[1] = 1;
4883 res->block1[1] = r->N;
4884 res->wvhdl[0]=(int*)omAlloc(r->N*sizeof(int));
4885 for(int i=0;i<r->N;i++)
4886 {
4887 r->wvhdl[0][i]=(*w)[i];
4888 }
4889 rComplete(res, 1);
4890 if (r->qideal!=NULL) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
4891#ifdef HAVE_PLURAL
4892 if (rIsPluralRing(r))
4893 {
4894 if ( nc_rComplete(r, res, false) ) // no qideal!
4895 {
4896#ifndef SING_NDEBUG
4897 WarnS("error in nc_rComplete");
4898#endif
4899 }
4900 }
4901#endif
4902// rChangeCurrRing(res);
4903 return res;
4904}
int BOOLEAN
Definition auxiliary.h:87
const CanonicalForm & w
Definition facAbsFact.cc:51
@ ringorder_Wp
Definition ring.h:82

◆ rChangeSComps()

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

Definition at line 4414 of file ring.cc.

4415{
4416#ifdef PDEBUG
4418#else
4420#endif
4421}
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
static void rNChangeSComps(int *currComponents, long *currShiftedComponents, ring r)
Definition ring.cc:4376
static void rDBChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition ring.cc:4392
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 3861 of file ring.cc.

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

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

◆ rCopy()

ring rCopy ( ring r)

Definition at line 1731 of file ring.cc.

1732{
1733 if (r == NULL) return NULL;
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)

◆ 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;
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 {
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)
#define omAlloc0Bin(bin)
VAR omBin sip_sring_bin
Definition ring.cc:43
void rUnComplete(ring r)
Definition ring.cc:3974
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;
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}
#define A
Definition sirandom.c:24

◆ rDBChangeSComps()

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

Definition at line 4392 of file ring.cc.

4396{
4397 assume(r->typ[1].ord_typ == ro_syzcomp);
4398
4399 r->typ[1].data.syzcomp.length = length;
4401}
int length() const

◆ rDBGetSComps()

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

Definition at line 4402 of file ring.cc.

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

◆ rDBTest()

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

Definition at line 2047 of file ring.cc.

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

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

◆ 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:569
void nc_rKill(ring r)
complete destructor
#define omFreeBin(addr, bin)

◆ rEnvelope()

ring rEnvelope ( ring R)

Definition at line 5732 of file ring.cc.

5735{
5736 ring Ropp = rOpposite(R);
5737 ring Renv = NULL;
5738 int stat = rSum(R, Ropp, Renv); /* takes care of qideals */
5739 if ( stat <=0 )
5740 WarnS("Error in rEnvelope at rSum");
5741 rTest(Renv);
5742 return Renv;
5743}
int rSum(ring r1, ring r2, ring &sum)
Definition ring.cc:1402
ring rOpposite(ring src)
Definition ring.cc:5342

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

◆ rGetDivMask()

static unsigned long rGetDivMask ( int bits)
static

get r->divmask depending on bits per exponent

Definition at line 4117 of file ring.cc.

4118{
4119 unsigned long divmask = 1;
4120 int i = bits;
4121
4122 while (i < BIT_SIZEOF_LONG)
4123 {
4124 divmask |= (((unsigned long) 1) << (unsigned long) i);
4125 i += bits;
4126 }
4127 return divmask;
4128}

◆ rGetExpSize() [1/2]

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

Definition at line 2579 of file ring.cc.

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

◆ rGetExpSize() [2/2]

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

Definition at line 2672 of file ring.cc.

2673{
2674 bitmask =rGetExpSize(bitmask, bits);
2676 int bits1;
2677 loop
2678 {
2679 if (bits == BIT_SIZEOF_LONG-1)
2680 {
2681 bits = BIT_SIZEOF_LONG - 1;
2682 return LONG_MAX;
2683 }
2684 unsigned long bitmask1 =rGetExpSize(bitmask+1, bits1);
2686 if ((((N+vars_per_long-1)/vars_per_long) ==
2688 {
2690 bits=bits1;
2691 bitmask=bitmask1;
2692 }
2693 else
2694 {
2695 return bitmask; /* and bits */
2696 }
2697 }
2698}
#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 5061 of file ring.cc.

5062{
5063 // Put the reference set F into the ring -ordering -recor
5064#if MYTEST
5065 Print("rIsIS(p: %d)\nF:", p);
5066 PrintLn();
5067#endif
5068
5069 if (r->typ==NULL)
5070 {
5071// dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
5072 return -1;
5073 }
5074
5075 int j = p; // Which IS record to use...
5076 for( int pos = 0; pos < r->OrdSize; pos++ )
5077 if( r->typ[pos].ord_typ == ro_is)
5078 if( j-- == 0 )
5079 return pos;
5080
5081 return -1;
5082}

◆ rGetMaxSyzComp()

int rGetMaxSyzComp ( int i,
const ring r )

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

Definition at line 5219 of file ring.cc.

5220{
5221 if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz) &&
5222 r->typ[0].data.syz.limit > 0 && i > 0)
5223 {
5224 assume(i <= r->typ[0].data.syz.limit);
5225 int j;
5226 for (j=0; j<r->typ[0].data.syz.limit; j++)
5227 {
5228 if (r->typ[0].data.syz.syz_index[j] == i &&
5229 r->typ[0].data.syz.syz_index[j+1] != i)
5230 {
5231 assume(r->typ[0].data.syz.syz_index[j+1] == i+1);
5232 return j;
5233 }
5234 }
5235 return r->typ[0].data.syz.limit;
5236 }
5237 else
5238 {
5239 #ifndef SING_NDEBUG
5240 WarnS("rGetMaxSyzComp: order c");
5241 #endif
5242 return 0;
5243 }
5244}

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

4424{
4425#ifdef PDEBUG
4427#else
4429#endif
4430}
static void rDBGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition ring.cc:4402

◆ rGetVar()

poly rGetVar ( const int varIndex,
const ring r )

Definition at line 5824 of file ring.cc.

5825{
5826 poly p = p_ISet(1, r);
5827 p_SetExp(p, varIndex, 1, r);
5828 p_Setm(p, r);
5829 return p;
5830}
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:488
static void p_Setm(poly p, const ring r)
Definition p_polys.h:233

◆ rGetWeightVec()

int64 * rGetWeightVec ( const ring r)

Definition at line 5283 of file ring.cc.

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

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

3079{
3080 rUnComplete(r);
3081 omFree(r->order);
3082 omFree(r->block0);
3083 omFree(r->block1);
3084 omFree(r->wvhdl[0]);
3085 omFree(r->wvhdl);
3087}

◆ rKillModifiedRing()

void rKillModifiedRing ( ring r)

Definition at line 3068 of file ring.cc.

3069{
3070 rUnComplete(r);
3071 omFree(r->order);
3072 omFree(r->block0);
3073 omFree(r->block1);
3074 omFree(r->wvhdl);
3076}

◆ rMinusVar()

ring rMinusVar ( const ring r,
char * v )

undo rPlusVar

Definition at line 5937 of file ring.cc.

5938{
5939 if (r->order[2]!=0)
5940 {
5941 WerrorS("only for rings with an ordering of one block");
5942 return NULL;
5943 }
5944 int p;
5945 if((r->order[0]==ringorder_C)
5946 ||(r->order[0]==ringorder_c))
5947 p=1;
5948 else
5949 p=0;
5950 if((r->order[p]!=ringorder_dp)
5951 && (r->order[p]!=ringorder_Dp)
5952 && (r->order[p]!=ringorder_lp)
5953 && (r->order[p]!=ringorder_rp)
5954 && (r->order[p]!=ringorder_ds)
5955 && (r->order[p]!=ringorder_Ds)
5956 && (r->order[p]!=ringorder_ls))
5957 {
5958 WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5959 return NULL;
5960 }
5961 ring R=rCopy0(r);
5962 int i=R->N-1;
5963 while(i>=0)
5964 {
5965 if (strcmp(R->names[i],v)==0)
5966 {
5967 R->N--;
5968 omFree(R->names[i]);
5969 for(int j=i;j<R->N;j++) R->names[j]=R->names[j+1];
5970 R->names=(char**)omReallocSize(R->names,r->N*sizeof(char_ptr),R->N*sizeof(char_ptr));
5971 }
5972 i--;
5973 }
5974 R->block1[p]=R->N;
5975 rComplete(R,1);
5976 return R;
5977}
#define omReallocSize(addr, o_size, size)
char * char_ptr
Definition ring.cc:42

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

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

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

◆ rModifyRing_Wp()

ring rModifyRing_Wp ( ring r,
int * weights )

construct Wp, C ring

Definition at line 2954 of file ring.cc.

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

◆ rNChangeSComps()

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

Definition at line 4376 of file ring.cc.

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

◆ rNGetSComps()

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

Definition at line 4384 of file ring.cc.

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

◆ rO_Align()

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

Definition at line 2197 of file ring.cc.

2198{
2199 // increment place to the next aligned one
2200 // (count as Exponent_t,align as longs)
2202 {
2203 place++;
2205 }
2206}

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

2467{
2468 if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2469 rO_Align(place,bitplace);
2470 // since we add something afterwards - it's better to start with anew!?
2471
2472 ord_struct.ord_typ = ro_isTemp;
2473 ord_struct.data.isTemp.start = place;
2474 #ifdef HAVE_OMALLOC
2475 ord_struct.data.isTemp.pVarOffset = (int *)omMemDup(v);
2476 #else
2477 ord_struct.data.isTemp.pVarOffset = (int *)omAlloc((N+1)*sizeof(int));
2478 memcpy(ord_struct.data.isTemp.pVarOffset,v,(N+1)*sizeof(int));
2479 #endif
2480 ord_struct.data.isTemp.suffixpos = -1;
2481
2482 // We will act as rO_Syz on our own!!!
2483 // Here we allocate an exponent as a level placeholder
2484 o[place]= -1;
2485 prev_ord=-1;
2486 place++;
2487}

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

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

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

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

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

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

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

2441{
2442 // ordering is derived from component number
2443 // let's reserve one Exponent_t for it
2444 if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
2445 rO_Align(place,bitplace);
2446 ord_struct.ord_typ=ro_syz;
2447 ord_struct.data.syz.place=place;
2448 ord_struct.data.syz.limit=syz_comp;
2449 if (syz_comp>0)
2450 ord_struct.data.syz.syz_index = (int*) omAlloc0((syz_comp+1)*sizeof(int));
2451 else
2452 ord_struct.data.syz.syz_index = NULL;
2453 ord_struct.data.syz.curr_index = 1;
2454 o[place]= -1;
2455 prev_ord=-1;
2456 place++;
2457}

◆ rO_Syzcomp()

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

Definition at line 2424 of file ring.cc.

2426{
2427 // ordering is derived from component number
2428 rO_Align(place,bitplace);
2429 ord_struct.ord_typ=ro_syzcomp;
2430 ord_struct.data.syzcomp.place=place;
2431 ord_struct.data.syzcomp.Components=NULL;
2432 ord_struct.data.syzcomp.ShiftedComponents=NULL;
2433 o[place]=1;
2434 prev_ord=1;
2435 place++;
2436 rO_Align(place,bitplace);
2437}

◆ rO_TDegree()

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

Definition at line 2208 of file ring.cc.

2210{
2211 // degree (aligned) of variables v_start..v_end, ordsgn 1
2212 rO_Align(place,bitplace);
2213 ord_struct.ord_typ=ro_dp;
2214 ord_struct.data.dp.start=start;
2215 ord_struct.data.dp.end=end;
2216 ord_struct.data.dp.place=place;
2217 o[place]=1;
2218 place++;
2219 rO_Align(place,bitplace);
2220}

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

2224{
2225 // degree (aligned) of variables v_start..v_end, ordsgn -1
2226 rO_Align(place,bitplace);
2227 ord_struct.ord_typ=ro_dp;
2228 ord_struct.data.dp.start=start;
2229 ord_struct.data.dp.end=end;
2230 ord_struct.data.dp.place=place;
2231 o[place]=-1;
2232 place++;
2233 rO_Align(place,bitplace);
2234}

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

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

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

2300{
2301 // weighted degree (aligned) of variables v_start..v_end, ordsgn 1,
2302 // reserved 2 places
2303 rO_Align(place,bitplace);
2304 ord_struct.ord_typ=ro_wp64;
2305 ord_struct.data.wp64.start=start;
2306 ord_struct.data.wp64.end=end;
2307 ord_struct.data.wp64.place=place;
2308 #ifdef HAVE_OMALLOC
2309 ord_struct.data.wp64.weights64=weights;
2310 #else
2311 int l=end-start+1;
2312 ord_struct.data.wp64.weights64=(int64*)omAlloc(l*sizeof(int64));
2313 for(int i=0;i<l;i++) ord_struct.data.wp64.weights64[i]=weights[i];
2314 #endif
2315 o[place]=1;
2316 place++;
2317 o[place]=1;
2318 place++;
2319 rO_Align(place,bitplace);
2320}

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

2324{
2325 // weighted degree (aligned) of variables v_start..v_end, ordsgn -1
2326 while((start<end) && (weights[0]==0)) { start++; weights++; }
2327 while((start<end) && (weights[end-start]==0)) { end--; }
2328 rO_Align(place,bitplace);
2329 ord_struct.ord_typ=ro_wp;
2330 ord_struct.data.wp.start=start;
2331 ord_struct.data.wp.end=end;
2332 ord_struct.data.wp.place=place;
2333 ord_struct.data.wp.weights=weights;
2334 o[place]=-1;
2335 place++;
2336 rO_Align(place,bitplace);
2337 int i;
2338 for(i=start;i<=end;i++)
2339 {
2340 if(weights[i-start]<0)
2341 {
2342 ord_struct.ord_typ=ro_wp_neg;
2343 break;
2344 }
2345 }
2346}

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

2278{
2279 assume(weights != NULL);
2280
2281 // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
2282// while((start<end) && (weights[0]==0)) { start++; weights++; }
2283// while((start<end) && (weights[end-start]==0)) { end--; }
2284 rO_Align(place,bitplace);
2285 ord_struct.ord_typ=ro_am;
2286 ord_struct.data.am.start=start;
2287 ord_struct.data.am.end=end;
2288 ord_struct.data.am.place=place;
2289 ord_struct.data.am.weights=weights;
2290 ord_struct.data.am.weights_m = weights + (end-start+1);
2291 ord_struct.data.am.len_gen=weights[end-start+1];
2292 assume( ord_struct.data.am.weights_m[0] == ord_struct.data.am.len_gen );
2293 o[place]=1;
2294 place++;
2295 rO_Align(place,bitplace);
2296}

◆ rOpposite()

ring rOpposite ( ring src)

Definition at line 5342 of file ring.cc.

5346{
5347 if (src == NULL) return(NULL);
5348
5349 //rChangeCurrRing(src);
5350#ifdef RDEBUG
5351 rTest(src);
5352// rWrite(src);
5353// rDebugPrint(src);
5354#endif
5355
5356 ring r = rCopy0(src,FALSE);
5357 if (src->qideal != NULL)
5358 {
5359 id_Delete(&(r->qideal), src);
5360 }
5361
5362 // change vars v1..vN -> vN..v1
5363 int i;
5364 int i2 = (rVar(r)-1)/2;
5365 for(i=i2; i>=0; i--)
5366 {
5367 // index: 0..N-1
5368 //Print("ex var names: %d <-> %d\n",i,rOppVar(r,i));
5369 // exchange names
5370 char *p;
5371 p = r->names[rVar(r)-1-i];
5372 r->names[rVar(r)-1-i] = r->names[i];
5373 r->names[i] = p;
5374 }
5375// i2=(rVar(r)+1)/2;
5376// for(int i=i2; i>0; i--)
5377// {
5378// // index: 1..N
5379// //Print("ex var places: %d <-> %d\n",i,rVar(r)+1-i);
5380// // exchange VarOffset
5381// int t;
5382// t=r->VarOffset[i];
5383// r->VarOffset[i]=r->VarOffset[rOppVar(r,i)];
5384// r->VarOffset[rOppVar(r,i)]=t;
5385// }
5386 // change names:
5387 // TODO: does this work the same way for Letterplace?
5388 for (i=rVar(r)-1; i>=0; i--)
5389 {
5390 char *p=r->names[i];
5391 if(isupper(*p)) *p = tolower(*p);
5392 else *p = toupper(*p);
5393 }
5394 // change ordering: listing
5395 // change ordering: compare
5396// for(i=0; i<r->OrdSize; i++)
5397// {
5398// int t,tt;
5399// switch(r->typ[i].ord_typ)
5400// {
5401// case ro_dp:
5402// //
5403// t=r->typ[i].data.dp.start;
5404// r->typ[i].data.dp.start=rOppVar(r,r->typ[i].data.dp.end);
5405// r->typ[i].data.dp.end=rOppVar(r,t);
5406// break;
5407// case ro_wp:
5408// case ro_wp_neg:
5409// {
5410// t=r->typ[i].data.wp.start;
5411// r->typ[i].data.wp.start=rOppVar(r,r->typ[i].data.wp.end);
5412// r->typ[i].data.wp.end=rOppVar(r,t);
5413// // invert r->typ[i].data.wp.weights
5414// rOppWeight(r->typ[i].data.wp.weights,
5415// r->typ[i].data.wp.end-r->typ[i].data.wp.start);
5416// break;
5417// }
5418// //case ro_wp64:
5419// case ro_syzcomp:
5420// case ro_syz:
5421// WerrorS("not implemented in rOpposite");
5422// // should not happen
5423// break;
5424//
5425// case ro_cp:
5426// t=r->typ[i].data.cp.start;
5427// r->typ[i].data.cp.start=rOppVar(r,r->typ[i].data.cp.end);
5428// r->typ[i].data.cp.end=rOppVar(r,t);
5429// break;
5430// case ro_none:
5431// default:
5432// Werror("unknown type in rOpposite(%d)",r->typ[i].ord_typ);
5433// break;
5434// }
5435// }
5436 // Change order/block structures (needed for rPrint, rAdd etc.)
5437
5438 int j=0;
5439 int l=rBlocks(src);
5440 if ( ! rIsLPRing(src) )
5441 {
5442 // ie Plural or commutative
5443 for(i=0; src->order[i]!=0; i++)
5444 {
5445 switch (src->order[i])
5446 {
5447 case ringorder_c: /* c-> c */
5448 case ringorder_C: /* C-> C */
5449 case ringorder_no /*=0*/: /* end-of-block */
5450 r->order[j]=src->order[i];
5451 j++; break;
5452 case ringorder_lp: /* lp -> rp */
5453 r->order[j]=ringorder_rp;
5454 r->block0[j]=rOppVar(r, src->block1[i]);
5455 r->block1[j]=rOppVar(r, src->block0[i]);
5456 j++;break;
5457 case ringorder_rp: /* rp -> lp */
5458 r->order[j]=ringorder_lp;
5459 r->block0[j]=rOppVar(r, src->block1[i]);
5460 r->block1[j]=rOppVar(r, src->block0[i]);
5461 j++;break;
5462 case ringorder_dp: /* dp -> a(1..1),ls */
5463 {
5464 l=rRealloc1(r,l,j);
5465 r->order[j]=ringorder_a;
5466 r->block0[j]=rOppVar(r, src->block1[i]);
5467 r->block1[j]=rOppVar(r, src->block0[i]);
5468 r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
5469 for(int k=r->block0[j]; k<=r->block1[j]; k++)
5470 r->wvhdl[j][k-r->block0[j]]=1;
5471 j++;
5472 r->order[j]=ringorder_ls;
5473 r->block0[j]=rOppVar(r, src->block1[i]);
5474 r->block1[j]=rOppVar(r, src->block0[i]);
5475 j++;
5476 break;
5477 }
5478 case ringorder_Dp: /* Dp -> a(1..1),rp */
5479 {
5480 l=rRealloc1(r,l,j);
5481 r->order[j]=ringorder_a;
5482 r->block0[j]=rOppVar(r, src->block1[i]);
5483 r->block1[j]=rOppVar(r, src->block0[i]);
5484 r->wvhdl[j]=(int*)omAlloc((r->block1[j]-r->block0[j]+1)*sizeof(int));
5485 for(int k=r->block0[j]; k<=r->block1[j]; k++)
5486 r->wvhdl[j][k-r->block0[j]]=1;
5487 j++;
5488 r->order[j]=ringorder_rp;
5489 r->block0[j]=rOppVar(r, src->block1[i]);
5490 r->block1[j]=rOppVar(r, src->block0[i]);
5491 j++;
5492 break;
5493 }
5494 case ringorder_wp: /* wp -> a(...),ls */
5495 {
5496 l=rRealloc1(r,l,j);
5497 r->order[j]=ringorder_a;
5498 r->block0[j]=rOppVar(r, src->block1[i]);
5499 r->block1[j]=rOppVar(r, src->block0[i]);
5500 r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
5501 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5502 j++;
5503 r->order[j]=ringorder_ls;
5504 r->block0[j]=rOppVar(r, src->block1[i]);
5505 r->block1[j]=rOppVar(r, src->block0[i]);
5506 j++;
5507 break;
5508 }
5509 case ringorder_Wp: /* Wp -> a(...),rp */
5510 {
5511 l=rRealloc1(r,l,j);
5512 r->order[j]=ringorder_a;
5513 r->block0[j]=rOppVar(r, src->block1[i]);
5514 r->block1[j]=rOppVar(r, src->block0[i]);
5515 r->wvhdl[j]=r->wvhdl[j+1]; r->wvhdl[j+1]=NULL;
5516 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5517 j++;
5518 r->order[j]=ringorder_rp;
5519 r->block0[j]=rOppVar(r, src->block1[i]);
5520 r->block1[j]=rOppVar(r, src->block0[i]);
5521 j++;
5522 break;
5523 }
5524 case ringorder_M: /* M -> M */
5525 {
5526 r->order[j]=ringorder_M;
5527 r->block0[j]=rOppVar(r, src->block1[i]);
5528 r->block1[j]=rOppVar(r, src->block0[i]);
5529 int n=r->block1[j]-r->block0[j];
5530 /* M is a (n+1)x(n+1) matrix */
5531 for (int nn=0; nn<=n; nn++)
5532 {
5533 rOppWeight(&(r->wvhdl[j][nn*(n+1)]), n /*r->block1[j]-r->block0[j]*/);
5534 }
5535 j++;
5536 break;
5537 }
5538 case ringorder_a: /* a(...),ls -> wp/dp */
5539 {
5540 r->block0[j]=rOppVar(r, src->block1[i]);
5541 r->block1[j]=rOppVar(r, src->block0[i]);
5542 rOppWeight(r->wvhdl[j], r->block1[j]-r->block0[j]);
5543 if (src->order[i+1]==ringorder_ls)
5544 {
5545 r->order[j]=ringorder_wp;
5546 i++;
5547 //l=rReallocM1(r,l,j);
5548 }
5549 else
5550 {
5551 r->order[j]=ringorder_a;
5552 }
5553 j++;
5554 break;
5555 }
5556 // not yet done:
5557 case ringorder_ls:
5558 case ringorder_rs:
5559 case ringorder_ds:
5560 case ringorder_Ds:
5561 case ringorder_ws:
5562 case ringorder_Ws:
5563 case ringorder_am:
5564 case ringorder_a64:
5565 // should not occur:
5566 case ringorder_S:
5567 case ringorder_IS:
5568 case ringorder_s:
5569 case ringorder_aa:
5570 case ringorder_L:
5571 case ringorder_unspec:
5572 Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5573 break;
5574 }
5575 }
5576 } /* end if (!rIsLPRing(src)) */
5577 if (rIsLPRing(src))
5578 {
5579 // applies to Letterplace only
5580 // Letterplace conventions: dp<->Dp, lp<->rp
5581 // Wp(v) cannot be converted since wp(v) does not encode a monomial ordering
5582 // (a(w),<) is troublesome and thus postponed
5583 for(i=0; src->order[i]!=0; i++)
5584 {
5585 switch (src->order[i])
5586 {
5587 case ringorder_c: /* c-> c */
5588 case ringorder_C: /* C-> C */
5589 case ringorder_no /*=0*/: /* end-of-block */
5590 r->order[j]=src->order[i];
5591 j++; break;
5592 case ringorder_lp: /* lp -> rp */
5593 r->order[j]=ringorder_rp;
5594 r->block0[j]=rOppVar(r, src->block1[i]);
5595 r->block1[j]=rOppVar(r, src->block0[i]);
5596 j++;break;
5597 case ringorder_rp: /* rp -> lp */
5598 r->order[j]=ringorder_lp;
5599 r->block0[j]=rOppVar(r, src->block1[i]);
5600 r->block1[j]=rOppVar(r, src->block0[i]);
5601 j++;break;
5602 case ringorder_dp: /* dp -> Dp */
5603 {
5604 r->order[j]=ringorder_Dp;
5605 r->block0[j]=rOppVar(r, src->block1[i]);
5606 r->block1[j]=rOppVar(r, src->block0[i]);
5607 j++;break;
5608 }
5609 case ringorder_Dp: /* Dp -> dp*/
5610 {
5611 r->order[j]=ringorder_dp;
5612 r->block0[j]=rOppVar(r, src->block1[i]);
5613 r->block1[j]=rOppVar(r, src->block0[i]);
5614 j++;break;
5615 }
5616 // not clear how to do:
5617 case ringorder_wp:
5618 case ringorder_Wp:
5619 case ringorder_M:
5620 case ringorder_a:
5621 // not yet done:
5622 case ringorder_ls:
5623 case ringorder_rs:
5624 case ringorder_ds:
5625 case ringorder_Ds:
5626 case ringorder_ws:
5627 case ringorder_Ws:
5628 case ringorder_am:
5629 case ringorder_a64:
5630 // should not occur:
5631 case ringorder_S:
5632 case ringorder_IS:
5633 case ringorder_s:
5634 case ringorder_aa:
5635 case ringorder_L:
5636 case ringorder_unspec:
5637 Werror("order %s not (yet) supported", rSimpleOrdStr(src->order[i]));
5638 break;
5639 }
5640 }
5641 } /* end if (rIsLPRing(src)) */
5642 rComplete(r);
5643
5644 //rChangeCurrRing(r);
5645#ifdef RDEBUG
5646 rTest(r);
5647// rWrite(r);
5648// rDebugPrint(r);
5649#endif
5650
5651#ifdef HAVE_PLURAL
5652 // now, we initialize a non-comm structure on r
5653 if (rIsPluralRing(src))
5654 {
5655// assume( currRing == r);
5656
5657 int *perm = (int *)omAlloc0((rVar(r)+1)*sizeof(int));
5658 int *par_perm = NULL;
5659 nMapFunc nMap = n_SetMap(src->cf,r->cf);
5660 int ni,nj;
5661 for(i=1; i<=r->N; i++)
5662 {
5663 perm[i] = rOppVar(r,i);
5664 }
5665
5666 matrix C = mpNew(rVar(r),rVar(r));
5667 matrix D = mpNew(rVar(r),rVar(r));
5668
5669 for (i=1; i< rVar(r); i++)
5670 {
5671 for (j=i+1; j<=rVar(r); j++)
5672 {
5673 ni = r->N +1 - i;
5674 nj = r->N +1 - j; /* i<j ==> nj < ni */
5675
5676 assume(MATELEM(src->GetNC()->C,i,j) != NULL);
5677 MATELEM(C,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,r, nMap,par_perm,rPar(src));
5678
5679 if(MATELEM(src->GetNC()->D,i,j) != NULL)
5680 MATELEM(D,nj,ni) = p_PermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,r, nMap,par_perm,rPar(src));
5681 }
5682 }
5683
5684 id_Test((ideal)C, r);
5685 id_Test((ideal)D, r);
5686
5687 if (nc_CallPlural(C, D, NULL, NULL, r, false, false, true, r)) // no qring setup!
5688 WarnS("Error initializing non-commutative multiplication!");
5689
5690#ifdef RDEBUG
5691 rTest(r);
5692// rWrite(r);
5693// rDebugPrint(r);
5694#endif
5695
5696 assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
5697
5698 omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
5699 }
5700#endif /* HAVE_PLURAL */
5701
5702 /* now oppose the qideal for qrings */
5703 if (src->qideal != NULL)
5704 {
5705#ifdef HAVE_PLURAL
5706 r->qideal = idOppose(src, src->qideal, r); // into the currRing: r
5707#else
5708 r->qideal = id_Copy(src->qideal, r); // ?
5709#endif
5710
5711#ifdef HAVE_PLURAL
5712 if( rIsPluralRing(r) )
5713 {
5715#ifdef RDEBUG
5716 rTest(r);
5717// rWrite(r);
5718// rDebugPrint(r);
5719#endif
5720 }
5721#endif
5722 }
5723#ifdef HAVE_PLURAL
5724 if( rIsPluralRing(r) )
5725 assume( ncRingType(r) == ncRingType(src) );
5726#endif
5727 rTest(r);
5728
5729 return r;
5730}
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)
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:5339
const char * rSimpleOrdStr(int ord)
Definition ring.cc:77
static void rOppWeight(int *w, int l)
Definition ring.cc:5326
static int rRealloc1(ring r, int size, int pos)
Definition ring.cc:5303
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 5326 of file ring.cc.

5327{
5328 /* works for commutative/Plural; need to be changed for Letterplace */
5329 /* Letterpace: each block of vars needs to be reverted on it own */
5330 int i2=(l+1)/2;
5331 for(int j=0; j<=i2; j++)
5332 {
5333 int t=w[j];
5334 w[j]=w[l-j];
5335 w[l-j]=t;
5336 }
5337}

◆ rOptimizeLDeg()

static void rOptimizeLDeg ( ring r)
static

Definition at line 3159 of file ring.cc.

3160{
3161 if (r->pFDeg == p_Deg)
3162 {
3163 if (r->pLDeg == pLDeg1)
3164 r->pLDeg = pLDeg1_Deg;
3165 if (r->pLDeg == pLDeg1c)
3166 r->pLDeg = pLDeg1c_Deg;
3167 }
3168 else if (r->pFDeg == p_Totaldegree)
3169 {
3170 if (r->pLDeg == pLDeg1)
3171 r->pLDeg = pLDeg1_Totaldegree;
3172 if (r->pLDeg == pLDeg1c)
3173 r->pLDeg = pLDeg1c_Totaldegree;
3174 }
3175 else if (r->pFDeg == p_WFirstTotalDegree)
3176 {
3177 if (r->pLDeg == pLDeg1)
3178 r->pLDeg = pLDeg1_WFirstTotalDegree;
3179 if (r->pLDeg == pLDeg1c)
3180 r->pLDeg = pLDeg1c_WFirstTotalDegree;
3181 }
3182 r->pLDegOrig = r->pLDeg;
3183}
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_dp()

BOOLEAN rOrd_is_dp ( const ring r)

Definition at line 2026 of file ring.cc.

2027{
2028 // Hmm.... what about Syz orderings?
2029 return (rVar(r) > 1 &&
2030 (rHasSimpleOrder(r) &&
2031 (r->order[0]==ringorder_dp) ||
2032 (r->order[1]==ringorder_dp)));
2033}

◆ rOrd_is_MixedDegree_Ordering()

BOOLEAN rOrd_is_MixedDegree_Ordering ( ring r)

Definition at line 3437 of file ring.cc.

3438{
3439 int i;
3440 poly p=p_One(r);
3441 p_SetExp(p,1,1,r);
3442 p_Setm(p,r);
3443 int vz=sign(p_FDeg(p,r));
3444 for(i=2;i<=rVar(r);i++)
3445 {
3446 p_SetExp(p,i-1,0,r);
3447 p_SetExp(p,i,1,r);
3448 p_Setm(p,r);
3449 if (sign(p_FDeg(p,r))!=vz)
3450 {
3451 p_Delete(&p,r);
3452 return TRUE;
3453 }
3454 }
3455 p_Delete(&p,r);
3456 return FALSE;
3457}
static long p_FDeg(const poly p, const ring r)
Definition p_polys.h:380
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:901
static int sign(int x)
Definition ring.cc:3436

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

2037{
2038 // Hmm.... what about Syz orderings?
2039 return ((rVar(r) > 1) &&
2040 rHasSimpleOrder(r) &&
2043}
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}
ro_typ ord_typ
Definition ring.h:220

◆ 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);
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;
615 StringAppend(",L(%ld)",mm);
616 }
617 return StringEndS();
618 }
619 StringAppendS(",");
620 }
621}
#define StringAppend
Definition emacs.cc:79
const int MAX_INT_VAL
Definition mylimits.h:12
void StringSetS(const char *st)
Definition reporter.cc:128
void StringAppendS(const char *st)
Definition reporter.cc:107
char * StringEndS()
Definition reporter.cc:151

◆ rParStr()

char * rParStr ( ring r)

Definition at line 649 of file ring.cc.

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

◆ rPlusVar()

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

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

Definition at line 5855 of file ring.cc.

5856{
5857 if (r->order[2]!=0)
5858 {
5859 WerrorS("only for rings with an ordering of one block");
5860 return NULL;
5861 }
5862 int p;
5863 if((r->order[0]==ringorder_C)
5864 ||(r->order[0]==ringorder_c))
5865 p=1;
5866 else
5867 p=0;
5868 if((r->order[p]!=ringorder_dp)
5869 && (r->order[p]!=ringorder_Dp)
5870 && (r->order[p]!=ringorder_lp)
5871 && (r->order[p]!=ringorder_rp)
5872 && (r->order[p]!=ringorder_ds)
5873 && (r->order[p]!=ringorder_Ds)
5874 && (r->order[p]!=ringorder_ls))
5875 {
5876 WerrorS("ordering must be dp,Dp,lp,rp,ds,Ds or ls");
5877 return NULL;
5878 }
5879 for(int i=r->N-1;i>=0;i--)
5880 {
5881 if (strcmp(r->names[i],v)==0)
5882 {
5883 Werror("duplicate variable name >>%s<<",v);
5884 return NULL;
5885 }
5886 }
5887 ring R=rCopy0(r);
5888 char **names;
5889 #ifdef HAVE_SHIFTBBA
5890 if (rIsLPRing(r))
5891 {
5892 R->isLPring=r->isLPring+1;
5893 R->N=((r->N)/r->isLPring)+r->N;
5894 names=(char**)omAlloc(R->N*sizeof(char_ptr));
5895 if (left)
5896 {
5897 for(int b=0;b<((r->N)/r->isLPring);b++)
5898 {
5899 names[b*R->isLPring]=omStrDup(v);
5900 for(int i=R->isLPring-1;i>0;i--)
5901 names[i+b*R->isLPring]=R->names[i-1+b*r->isLPring];
5902 }
5903 }
5904 else
5905 {
5906 for(int b=0;b<((r->N)/r->isLPring);b++)
5907 {
5908 names[(b+1)*R->isLPring-1]=omStrDup(v);
5909 for(int i=R->isLPring-2;i>=0;i--)
5910 names[i+b*R->isLPring]=R->names[i+b*r->isLPring];
5911 }
5912 }
5913 }
5914 else
5915 #endif
5916 {
5917 R->N++;
5918 names=(char**)omAlloc(R->N*sizeof(char_ptr));
5919 if (left)
5920 {
5921 names[0]=omStrDup(v);
5922 for(int i=R->N-1;i>0;i--) names[i]=R->names[i-1];
5923 }
5924 else
5925 {
5926 names[R->N-1]=omStrDup(v);
5927 for(int i=R->N-2;i>=0;i--) names[i]=R->names[i];
5928 }
5929 }
5930 omFreeSize(R->names,r->N*sizeof(char_ptr));
5931 R->names=names;
5932 R->block1[p]=R->N;
5933 rComplete(R);
5934 return R;
5935}

◆ rRealloc1()

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

Definition at line 5303 of file ring.cc.

5304{
5305 r->order=(rRingOrder_t*)omReallocSize(r->order, size*sizeof(rRingOrder_t), (size+1)*sizeof(rRingOrder_t));
5306 r->block0=(int*)omReallocSize(r->block0, size*sizeof(int), (size+1)*sizeof(int));
5307 r->block1=(int*)omReallocSize(r->block1, size*sizeof(int), (size+1)*sizeof(int));
5308 r->wvhdl=(int **)omReallocSize(r->wvhdl,size*sizeof(int *), (size+1)*sizeof(int *));
5309 for(int k=size; k>pos; k--) r->wvhdl[k]=r->wvhdl[k-1];
5310 r->order[size]=(rRingOrder_t)0;
5311 size++;
5312 return size;
5313}
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 4091 of file ring.cc.

4092{
4093 int* shifts = (int*) omAlloc(r->ExpL_Size*sizeof(int));
4094 int i;
4095 // initialize shifts
4096 for (i=0;i<r->ExpL_Size;i++)
4098
4099 // find minimal bit shift in each long exp entry
4100 for (i=1;i<=r->N;i++)
4101 {
4102 if (shifts[r->VarOffset[i] & 0xffffff] > r->VarOffset[i] >> 24)
4103 shifts[r->VarOffset[i] & 0xffffff] = r->VarOffset[i] >> 24;
4104 }
4105 // reset r->VarOffset: set the minimal shift to 0
4106 for (i=1;i<=r->N;i++)
4107 {
4108 if (shifts[r->VarOffset[i] & 0xffffff] != 0)
4109 r->VarOffset[i]
4110 = (r->VarOffset[i] & 0xffffff) |
4111 (((r->VarOffset[i] >> 24) - shifts[r->VarOffset[i] & 0xffffff]) << 24);
4112 }
4113 omFree(shifts);
4114}

◆ rRing_has_CompLastBlock()

BOOLEAN rRing_has_CompLastBlock ( const ring r)

Definition at line 5246 of file ring.cc.

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

◆ rRing_ord_pure_dp()

BOOLEAN rRing_ord_pure_dp ( const ring r)

Definition at line 5253 of file ring.cc.

5254{
5255 if ((r->order[0]==ringorder_dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5256 return TRUE;
5257 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5258 && ((r->order[1]==ringorder_dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5259 return TRUE;
5260 return FALSE;
5261}

◆ rRing_ord_pure_Dp()

BOOLEAN rRing_ord_pure_Dp ( const ring r)

Definition at line 5263 of file ring.cc.

5264{
5265 if ((r->order[0]==ringorder_Dp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5266 return TRUE;
5267 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5268 && ((r->order[1]==ringorder_Dp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5269 return TRUE;
5270 return FALSE;
5271}

◆ rRing_ord_pure_lp()

BOOLEAN rRing_ord_pure_lp ( const ring r)

Definition at line 5273 of file ring.cc.

5274{
5275 if ((r->order[0]==ringorder_lp) &&(r->block0[0]==1) &&(r->block1[0]==r->N))
5276 return TRUE;
5277 if (((r->order[0]==ringorder_c)||(r->order[0]==ringorder_C))
5278 && ((r->order[1]==ringorder_lp) &&(r->block0[1]==1) &&(r->block1[1]==r->N)))
5279 return TRUE;
5280 return FALSE;
5281}

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

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

◆ rSetFirstWv()

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

Definition at line 3127 of file ring.cc.

3128{
3129 // cheat for ringorder_aa
3130 if (order[i] == ringorder_aa)
3131 i++;
3132 if(block1[i]!=r->N) r->LexOrder=TRUE;
3133 r->firstBlockEnds=block1[i];
3134 r->firstwv = wvhdl[i];
3135 if ((order[i]== ringorder_ws)
3136 || (order[i]==ringorder_Ws)
3137 || (order[i]== ringorder_wp)
3138 || (order[i]==ringorder_Wp)
3139 || (order[i]== ringorder_a)
3140 /*|| (order[i]==ringorder_A)*/)
3141 {
3142 int j;
3143 for(j=block1[i]-block0[i];j>=0;j--)
3144 {
3145 if (r->firstwv[j]==0) r->LexOrder=TRUE;
3146 }
3147 }
3148 else if (order[i]==ringorder_a64)
3149 {
3150 int j;
3151 int64 *w=rGetWeightVec(r);
3152 for(j=block1[i]-block0[i];j>=0;j--)
3153 {
3154 if (w[j]==0) r->LexOrder=TRUE;
3155 }
3156 }
3157}
int64 * rGetWeightVec(const ring r)
Definition ring.cc:5283

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

5094{
5095 // Put the reference set F into the ring -ordering -recor
5096
5097 if (r->typ==NULL)
5098 {
5099 dReportError("Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
5100 return FALSE;
5101 }
5102
5103
5104 int pos = rGetISPos(p, r);
5105
5106 if( pos == -1 )
5107 {
5108 dReportError("Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
5109 return FALSE;
5110 }
5111
5112#if MYTEST
5113 if( i != r->typ[pos].data.is.limit )
5114 Print("Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
5115#endif
5116
5117 const ideal FF = idrHeadR(F, r, r); // id_Copy(F, r); // ???
5118
5119
5120 if( r->typ[pos].data.is.F != NULL)
5121 {
5122#if MYTEST
5123 PrintS("Deleting old reference set F... \n"); // idShow(r->typ[pos].data.is.F, r); PrintLn();
5124#endif
5125 id_Delete(&r->typ[pos].data.is.F, r);
5126 r->typ[pos].data.is.F = NULL;
5127 }
5128
5129 assume(r->typ[pos].data.is.F == NULL);
5130
5131 r->typ[pos].data.is.F = FF; // F is owened by ring now! TODO: delete at the end!
5132
5133 r->typ[pos].data.is.limit = i; // First induced component
5134
5135#if MYTEST
5136 PrintS("New reference set FF : \n"); idShow(FF, r, r, 1); PrintLn();
5137#endif
5138
5139 return TRUE;
5140}
void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)

◆ rSetNegWeight()

static void rSetNegWeight ( ring r)
static

Definition at line 3356 of file ring.cc.

3357{
3358 int i,l;
3359 if (r->typ!=NULL)
3360 {
3361 l=0;
3362 for(i=0;i<r->OrdSize;i++)
3363 {
3364 if((r->typ[i].ord_typ==ro_wp_neg)
3365 ||(r->typ[i].ord_typ==ro_am))
3366 l++;
3367 }
3368 if (l>0)
3369 {
3370 r->NegWeightL_Size=l;
3371 r->NegWeightL_Offset=(int *) omAlloc(l*sizeof(int));
3372 l=0;
3373 for(i=0;i<r->OrdSize;i++)
3374 {
3375 if(r->typ[i].ord_typ==ro_wp_neg)
3376 {
3377 r->NegWeightL_Offset[l]=r->typ[i].data.wp.place;
3378 l++;
3379 }
3380 else if(r->typ[i].ord_typ==ro_am)
3381 {
3382 r->NegWeightL_Offset[l]=r->typ[i].data.am.place;
3383 l++;
3384 }
3385 }
3386 return;
3387 }
3388 }
3389 r->NegWeightL_Size = 0;
3390 r->NegWeightL_Offset = NULL;
3391}

◆ rSetOption()

static void rSetOption ( ring r)
static

Definition at line 3393 of file ring.cc.

3394{
3395 // set redthrough
3396 if (!TEST_OPT_OLDSTD && r->OrdSgn == 1 && ! r->LexOrder)
3397 r->options |= Sy_bit(OPT_REDTHROUGH);
3398 else
3399 r->options &= ~Sy_bit(OPT_REDTHROUGH);
3400
3401 // set intStrategy
3402 if ( (r->cf->extRing!=NULL)
3403 || rField_is_Q(r)
3404 || rField_is_Ring(r)
3405 )
3406 r->options |= Sy_bit(OPT_INTSTRATEGY);
3407 else
3408 r->options &= ~Sy_bit(OPT_INTSTRATEGY);
3409
3410 // set redTail
3411 if (r->LexOrder || r->OrdSgn == -1 || (r->cf->extRing!=NULL))
3412 r->options &= ~Sy_bit(OPT_REDTAIL);
3413 else
3414 r->options |= Sy_bit(OPT_REDTAIL);
3415}
#define OPT_INTSTRATEGY
Definition options.h:92
#define OPT_REDTAIL
Definition options.h:91
#define TEST_OPT_OLDSTD
Definition options.h:123
#define OPT_REDTHROUGH
Definition options.h:82
#define Sy_bit(x)
Definition options.h:31
static BOOLEAN rField_is_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 3089 of file ring.cc.

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

◆ rSetSyzComp()

void rSetSyzComp ( int k,
const ring r )

Definition at line 5147 of file ring.cc.

5148{
5149 if(k < 0)
5150 {
5151 dReportError("rSetSyzComp with negative limit!");
5152 return;
5153 }
5154
5155 assume( k >= 0 );
5156 if (TEST_OPT_PROT) Print("{%d}", k);
5157 if ((r->typ!=NULL) && (r->typ[0].ord_typ==ro_syz))
5158 {
5159 r->block0[0]=r->block1[0] = k;
5160 if( k == r->typ[0].data.syz.limit )
5161 return; // nothing to do
5162
5163 int i;
5164 if (r->typ[0].data.syz.limit == 0)
5165 {
5166 r->typ[0].data.syz.syz_index = (int*) omAlloc0((k+1)*sizeof(int));
5167 r->typ[0].data.syz.syz_index[0] = 0;
5168 r->typ[0].data.syz.curr_index = 1;
5169 }
5170 else
5171 {
5172 r->typ[0].data.syz.syz_index = (int*)
5173 omReallocSize(r->typ[0].data.syz.syz_index,
5174 (r->typ[0].data.syz.limit+1)*sizeof(int),
5175 (k+1)*sizeof(int));
5176 }
5177 for (i=r->typ[0].data.syz.limit + 1; i<= k; i++)
5178 {
5179 r->typ[0].data.syz.syz_index[i] =
5180 r->typ[0].data.syz.curr_index;
5181 }
5182 if(k < r->typ[0].data.syz.limit) // ?
5183 {
5184#ifndef SING_NDEBUG
5185 Warn("rSetSyzComp called with smaller limit (%d) as before (%d)", k, r->typ[0].data.syz.limit);
5186#endif
5187 r->typ[0].data.syz.curr_index = 1 + r->typ[0].data.syz.syz_index[k];
5188 }
5189
5190
5191 r->typ[0].data.syz.limit = k;
5192 r->typ[0].data.syz.curr_index++;
5193 }
5194 else if(
5195 (r->typ!=NULL) &&
5196 (r->typ[0].ord_typ==ro_isTemp)
5197 )
5198 {
5199// (r->typ[currRing->typ[0].data.isTemp.suffixpos].data.is.limit == k)
5200#ifndef SING_NDEBUG
5201 Warn("rSetSyzComp(%d) in an IS ring! Be careful!", k);
5202#endif
5203 }
5204 else if (r->order[0]==ringorder_s)
5205 {
5206 r->block0[0] = r->block1[0] = k;
5207 }
5208 else if (r->order[0]!=ringorder_c)
5209 {
5210 dReportError("syzcomp in incompatible ring");
5211 }
5212#ifdef PDEBUG
5214 pDBsyzComp=k;
5215#endif
5216}
#define EXTERN_VAR
Definition globaldefs.h:6
#define TEST_OPT_PROT
Definition options.h:103
VAR int pDBsyzComp
Definition ring.cc:5143

◆ rSetVarL()

static void rSetVarL ( ring r)
static

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

Definition at line 4036 of file ring.cc.

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

◆ rSetWeightVec()

void rSetWeightVec ( ring r,
int64 * wv )

Definition at line 5293 of file ring.cc.

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

◆ 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:840

◆ 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
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)
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
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);
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
1198
1199 if ( (R1_is_nc) || (R2_is_nc))
1200 {
1203
1204#if 0
1205#ifdef RDEBUG
1206 rWrite(R1);
1207 rDebugPrint(R1);
1208#endif
1209#endif
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)
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);
1280
1281 if (MATELEM(D2,i,j) != NULL)
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);
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);
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
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
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) )
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)
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
ideal id_SimpleAdd(ideal h1, ideal h2, const ring R)
concat the lists h1 and h2 without zeros
#define Q
Definition sirandom.c:26

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

◆ rUnComplete()

void rUnComplete ( ring r)

Definition at line 3974 of file ring.cc.

3975{
3976 if (r == NULL) return;
3977 if (r->VarOffset != NULL)
3978 {
3979 if (r->OrdSize!=0 && r->typ != NULL)
3980 {
3981 for(int i = 0; i < r->OrdSize; i++)
3982 if( r->typ[i].ord_typ == ro_is) // Search for suffixes! (prefix have the same VarOffset)
3983 {
3984 id_Delete(&r->typ[i].data.is.F, r);
3985
3986 if( r->typ[i].data.is.pVarOffset != NULL )
3987 {
3988 omFreeSize((ADDRESS)r->typ[i].data.is.pVarOffset, (r->N +1)*sizeof(int));
3989 }
3990 }
3991 else if (r->typ[i].ord_typ == ro_syz)
3992 {
3993 if(r->typ[i].data.syz.limit > 0)
3994 omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*sizeof(int));
3995 }
3996 else if (r->typ[i].ord_typ == ro_syzcomp)
3997 {
3998 assume( r->typ[i].data.syzcomp.ShiftedComponents == NULL );
3999 assume( r->typ[i].data.syzcomp.Components == NULL );
4000// WarnS( "rUnComplete : ord_typ == ro_syzcomp was unhandled!!! Possibly memory leak!!!" );
4001#ifndef SING_NDEBUG
4002// assume(0);
4003#endif
4004 }
4005
4006 omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord)); r->typ = NULL;
4007 }
4008
4009 if (r->PolyBin != NULL)
4010 omUnGetSpecBin(&(r->PolyBin));
4011
4012 omFreeSize((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
4013 r->VarOffset=NULL;
4014
4015 if (r->ordsgn != NULL && r->CmpL_Size != 0)
4016 {
4017 omFreeSize((ADDRESS)r->ordsgn,r->ExpL_Size*sizeof(long));
4018 r->ordsgn=NULL;
4019 }
4020 if (r->p_Procs != NULL)
4021 {
4022 omFreeSize(r->p_Procs, sizeof(p_Procs_s));
4023 r->p_Procs=NULL;
4024 }
4025 omfreeSize(r->VarL_Offset, r->VarL_Size*sizeof(int));
4026 r->VarL_Offset=NULL;
4027 }
4028 if (r->NegWeightL_Offset!=NULL)
4029 {
4030 omFreeSize(r->NegWeightL_Offset, r->NegWeightL_Size*sizeof(int));
4031 r->NegWeightL_Offset=NULL;
4032 }
4033}
#define omfreeSize(addr, size)
#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
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 3436 of file ring.cc.

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

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

48{
49 " ?", ///< ringorder_no = 0,
50 "a", ///< ringorder_a,
51 "A", ///< ringorder_a64,
52 "c", ///< ringorder_c,
53 "C", ///< ringorder_C,
54 "M", ///< ringorder_M,
55 "S", ///< ringorder_S,
56 "s", ///< ringorder_s,
57 "lp", ///< ringorder_lp,
58 "dp", ///< ringorder_dp,
59 "rp", ///< ringorder_rp,
60 "Dp", ///< ringorder_Dp,
61 "wp", ///< ringorder_wp,
62 "Wp", ///< ringorder_Wp,
63 "ls", ///< ringorder_ls,
64 "ds", ///< ringorder_ds,
65 "Ds", ///< ringorder_Ds,
66 "ws", ///< ringorder_ws,
67 "Ws", ///< ringorder_Ws,
68 "am", ///< ringorder_am,
69 "L", ///< ringorder_L,
70 "aa", ///< ringorder_aa
71 "rs", ///< ringorder_rs,
72 "IS", ///< ringorder_IS
73 " _" ///< ringorder_unspec
74};

◆ sip_sring_bin

VAR omBin sip_sring_bin = omGetSpecBin(sizeof(ip_sring))

Definition at line 43 of file ring.cc.