My Project
Loading...
Searching...
No Matches
ring.h
Go to the documentation of this file.
1#ifndef RING_H
2#define RING_H
3/****************************************
4* Computer Algebra System SINGULAR *
5****************************************/
6/*
7* ABSTRACT - the interpreter related ring operations
8*/
9
10/* includes */
11#include "misc/auxiliary.h"
12#include "coeffs/coeffs.h"
13#include "misc/intvec.h"
14#include "misc/int64vec.h"
15#include "coeffs/coeffs.h" // ring,number
17//#include "polys/monomials/polys-impl.h"
18//
19
20/* forward declaration of types */
21class idrec; typedef idrec * idhdl; // _only_ for idhdl ip_sring::idroot
22struct p_Procs_s;
23typedef struct p_Procs_s p_Procs_s;
24class kBucket;
26
27struct sip_sideal;
28typedef struct sip_sideal * ideal;
29typedef struct sip_sideal const * const_ideal;
30
31struct sip_smap;
32typedef struct sip_smap * map;
33typedef struct sip_smap const * const_map;
34
35/* the function pointer types */
36
37typedef long (*pLDegProc)(poly p, int *length, ring r);
38typedef long (*pFDegProc)(poly p, ring r);
39typedef void (*p_SetmProc)(poly p, const ring r);
40
41
42/// returns a poly from dest_r which is a ShallowCopy of s_p from source_r
43/// assumes that source_r->N == dest_r->N and that orderings are the same
44typedef poly (*pShallowCopyDeleteProc)(poly s_p, ring source_r, ring dest_r,
45 omBin dest_bin);
46
47// ro_typ describes what to store at the corresping "data" place in p->exp
48// none of the directly corresponds to a ring ordering (ringorder_*)
49// as each ringorder_* blocks corrsponds to 0..2 sro-blocks
50typedef enum
51{
52 ro_dp, // total degree with weights 1
53 ro_wp, // total weighted degree with weights>0 in wvhdl
54 ro_am, // weights for vars + weights for gen
55 ro_wp64, // weighted64 degree weights in wvhdl
56 ro_wp_neg, // total weighted degree with weights in Z in wvhdl
57 // (with possibly negative weights)
58 ro_cp, // ??ordering duplicates variables
59 ro_syzcomp, // ??ordering indicates "subset" of component number (ringorder_S)
60 ro_syz, // component number if <=syzcomp else 0 (ringorder_s)
61 ro_isTemp, ro_is, // ??Induced Syzygy (Schreyer) ordering (and prefix data placeholder dummy) (ringorder_IS)
64ro_typ;
65
66/// order stuff
67typedef enum rRingOrder_t
68{
71 ringorder_a64, ///< for int64 weights
75 ringorder_S, ///< S?
76 ringorder_s, ///< s?
90 // the following are only used internally
91 ringorder_aa, ///< for idElimination, like a, except pFDeg, pWeigths ignore it
92 ringorder_rs, ///< opposite of ls
93 ringorder_IS, ///< Induced (Schreyer) ordering
96
97typedef enum rOrderType_t
98{
99 rOrderType_General = 0, ///< non-simple ordering as specified by currRing
100 rOrderType_CompExp, ///< simple ordering, component has priority
101 rOrderType_ExpComp, ///< simple ordering, exponent vector has priority
102 ///< component not compatible with exp-vector order
103 rOrderType_Exp, ///< simple ordering, exponent vector has priority
104 ///< component is compatible with exp-vector order
105 rOrderType_Syz, ///< syzygy ordering
106 rOrderType_Schreyer, ///< Schreyer ordering
107 rOrderType_Syz2dpc, ///< syzcomp2dpc
108 rOrderType_ExpNoComp ///< simple ordering, differences in component are
109 ///< not considered
111
112// ordering is a degree ordering
113struct sro_dp
114{
115 short place; // where degree is stored (in L):
116 short start; // bounds of ordering (in E):
117 short end;
118};
119typedef struct sro_dp sro_dp;
120
121// ordering is a weighted degree ordering
122struct sro_wp
123{
124 short place; // where weighted degree is stored (in L)
125 short start; // bounds of ordering (in E)
126 short end;
127 int *weights; // pointers into wvhdl field
128};
129typedef struct sro_wp sro_wp;
130
131// ordering is a weighted degree ordering
132struct sro_am
133{
134 short place; // where weighted degree is stored (in L)
135 short start; // bounds of ordering (in E)
136 short end;
137 short len_gen; // i>len_gen: weight(gen(i)):=0
138 int *weights; // pointers into wvhdl field of length (end-start+1) + len_gen + 1
139 // contents w_{start},... w_{end}, len, mod_w_1, .. mod_w_len, 0
140 int *weights_m; // pointers into wvhdl field of length len_gen + 1
141 // len_gen, mod_w_1, .. mod_w_len, 0
142
143};
144typedef struct sro_am sro_am;
145
146// ordering is a weighted degree ordering
148{
149 short place; // where weighted degree is stored (in L)
150 short start; // bounds of ordering (in E)
151 short end;
152 int64 *weights64; // pointers into wvhdl field
153};
154typedef struct sro_wp64 sro_wp64;
155
156// ordering duplicates variables
157struct sro_cp
158{
159 short place; // where start is copied to (in E)
160 short start; // bounds of sources of copied variables (in E)
161 short end;
162};
163typedef struct sro_cp sro_cp;
164
165// ordering indicates "subset" of component number
167{
168 short place; // where the index is stored (in L)
169 long *ShiftedComponents; // pointer into index field
171#ifdef PDEBUG
172 long length;
173#endif
174};
175typedef struct sro_syzcomp sro_syzcomp;
176
177// ordering with component number >syzcomp is lower
179{
180 short place; // where the index is stored (in L)
181 int limit; // syzcomp
182 int* syz_index; // mapping Component -> SyzIndex for Comp <= limit
183 int curr_index; // SyzIndex for Component > limit
184};
185
186typedef struct sro_syz sro_syz;
187// Induced Syzygy (Schreyer) ordering is built inductively as follows:
188// we look for changes made by ordering blocks which are between prefix/suffix markers:
189// that is: which variables where placed by them and where (judging by v)
190
191// due to prefix/suffix nature we need some placeholder:
192// prefix stores here initial state
193// suffix cleares this up
195{
196 short start; // 1st member SHOULD be short "place"
198 int* pVarOffset; // copy!
199};
200
201// So this is the actuall thing!
202// suffix uses last sro_ISTemp (cleares it up afterwards) and
203// creates this block
204struct sro_IS
205{
206 short start, end; // which part of L we want to want to update...
207 int* pVarOffset; // same as prefix!
208
209 int limit; // first referenced component
210
211 // reference poly set?? // Should it be owned by ring?!!!
212 ideal F; // reference leading (module)-monomials set. owned by ring...
213};
214
215typedef struct sro_IS sro_IS;
216typedef struct sro_ISTemp sro_ISTemp;
217
219{
221 int order_index; // comes from r->order[order_index]
222 union
223 {
224 sro_dp dp;
225 sro_wp wp;
226 sro_am am;
227 sro_wp64 wp64;
228 sro_cp cp;
229 sro_syzcomp syzcomp;
230 sro_syz syz;
231 sro_IS is;
232 sro_ISTemp isTemp;
234};
235
236#ifdef HAVE_PLURAL
237struct nc_struct;
238typedef struct nc_struct nc_struct;
239#endif
240class skStrategy;
242
243typedef poly (*NF_Proc)(ideal, ideal, poly, int, int, const ring _currRing);
244typedef ideal (*BBA_Proc) (const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring);
245
246
248{
249// each entry must have a description and a procedure defining it,
250// general ordering: pointer/structs, long, int, short, BOOLEAN/char/enum
251// general defining procedures: rInit, rComplete, interpreter, ??
252 idhdl idroot; /* local objects , interpreter*/
253 rRingOrder_t* order; /* array of orderings, rInit/rSleftvOrdering2Ordering */
254 int* block0; /* starting pos., rInit/rSleftvOrdering2Ordering*/
255 int* block1; /* ending pos., rInit/rSleftvOrdering2Ordering*/
256// char** parameter; /* names of parameters, rInit */
257 int** wvhdl; /* array of weight vectors, rInit/rSleftvOrdering2Ordering */
258 char ** names; /* array of variable names, rInit */
259
260 // what follows below here should be set by rComplete, _only_
261 long *ordsgn; /* array of +/- 1 (or 0) for comparing monomials */
262 /* ExpL_Size entries*/
263
264 // is NULL for lp or N == 1, otherwise non-NULL (with OrdSize > 0 entries) */
265 sro_ord* typ; /* array of orderings + sizes, OrdSize entries */
266 /* if NegWeightL_Size > 0, then NegWeightL_Offset[0..size_1] is index of longs
267 in ExpVector whose values need an offset due to negative weights */
268 /* array of NegWeigtL_Size indicies */
270
272
273// ideal minideal;
274// number minpoly; /* replaced by minideal->m[0] */
275 ideal qideal; /**< extension to the ring structure: qring, rInit, OR
276 for Q_a/Zp_a, rInit (replaces minideal!);
277 for a start, we assume that there is either no
278 or exactly one generator in minideal, playing
279 the role of the former minpoly; minideal may
280 also be NULL which coincides with the
281 no-generator-case **/
282
284
285 omBin PolyBin; /* Bin from where monoms are allocated */
286 intvec * pModW; /* std: module weights */
287 poly ppNoether; /* variables, set by procedures from hecke/kstd1:
288 the highest monomial below pHEdge */
289 void * ext_ref; /* libsing GAP object */
290// #ifdef HAVE_RINGS
291// unsigned int cf->ringtype; /* cring = 0 => coefficient field, cring = 1 => coeffs from Z/2^m */
292// mpz_ptr cf->modBase; /* Z/(ringflag^cf->modExponent)=Z/cf->modNumber*/
293// unsigned long cf->modExponent;
294// unsigned long cf->modNumber; /* Z/cf->modNumber */
295// mpz_ptr cf->modNumber;
296// #endif
297
298 unsigned long options; /* ring dependent options */
299
300// int ch; /* characteristic, rInit */
301 int ref; /* reference counter to the ring, interpreter */
302
303 short N; /* number of vars, rInit */
304
305 short OrdSgn; /* 1 for polynomial rings, -1 otherwise, rInit */
306
308#ifdef HAVE_PLURAL
310#endif
311
312#ifdef HAVE_SHIFTBBA
313 short isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
315#endif
316
320 BOOLEAN LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
321 BOOLEAN MixedOrder; // TRUE for global/local mixed orderings, FALSE otherwise
322 BOOLEAN pLexOrder; /* TRUE if the monomial ordering is not compatible with pFDeg */
323
324 BOOLEAN ComponentOrder; // 1 if ringorder_c, -1 for ringorder_C,ringorder_S,ringorder_s
325
326 // what follows below here should be set by rComplete, _only_
327 // contains component, but no weight fields in E */
328 short ExpL_Size; // size of exponent vector in long
329 short CmpL_Size; // portions which need to be compared
330 /* number of long vars in exp vector:
331 long vars are those longs in the exponent vector which are
332 occupied by variables, only */
334 short BitsPerExp; /* number of bits per exponent */
335 short ExpPerLong; /* maximal number of Exponents per long */
336 short pCompIndex; /* p->exp.e[pCompIndex] is the component */
337 short pOrdIndex; /* p->exp[pOrdIndex] is pGetOrd(p) */
338 short OrdSize; /* size of ord vector (in sro_ord) */
339
340 /* if >= 0, long vars in exp vector are consecutive and start there
341 if < 0, long vars in exp vector are not consecutive */
343
345 /* array of size VarL_Size,
346 VarL_Offset[i] gets i-th long var in exp vector */
348
349 /* mask for getting single exponents, also maxExp */
350 unsigned long bitmask;
351 /* wanted maxExp */
352 unsigned long wanted_maxExp;
353 /* mask used for divisiblity tests */
354 unsigned long divmask; // rComplete
355
356 p_Procs_s* p_Procs; // rComplete/p_ProcsSet
357
358 /* FDeg and LDeg */
359 pFDegProc pFDeg; // rComplete/rSetDegStuff
360 pLDegProc pLDeg; // rComplete/rSetDegStuff
361
362 /* as it was determined by rComplete */
364 /* and as it was determined before rOptimizeLDeg */
366
369#ifdef HAVE_PLURAL
370 private:
371 nc_struct* _nc; // private
372 public:
373 inline const nc_struct* GetNC() const { return _nc; }; // public!!!
374 inline nc_struct*& GetNC() { return _nc; }; // public!!!
375#endif
376 public:
377 operator coeffs() const { return cf; }
378};
379
380////////// DEPRECATED
381/////// void rChangeCurrRing(ring r);
382
383ring rDefault(int ch, int N, char **n);
384ring rDefault(const coeffs cf, int N, char **n, const rRingOrder_t o=ringorder_lp);
385ring rDefault(int ch, int N, char **n,int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl=NULL);
386ring rDefault(const coeffs cf, int N, char **n,int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl=NULL, unsigned long bitmask=0);
387unsigned long rGetExpSize(unsigned long bitmask, int & bits, int N);
388
389// #define rIsRingVar(A) r_IsRingVar(A,currRing)
390int r_IsRingVar(const char *n, char**names, int N);
391void rWrite(ring r, BOOLEAN details = FALSE);
392ring rCopy(ring r);
393ring rCopy0(const ring r, BOOLEAN copy_qideal = TRUE, BOOLEAN copy_ordering = TRUE);
394ring rCopy0AndAddA(ring r, int64vec *wv64, BOOLEAN copy_qideal = TRUE,
395 BOOLEAN copy_ordering = TRUE);
396ring rOpposite(ring r);
397ring rEnvelope(ring r);
398
399/// we must always have this test!
400static inline BOOLEAN rIsPluralRing(const ring r)
401{
402 assume(r != NULL);
403#ifdef HAVE_PLURAL
404 nc_struct *n;
405 return ((n=r->GetNC()) != NULL) /*&& (n->type != nc_error)*/;
406#else
407 return FALSE;
408#endif
409}
410
411static inline BOOLEAN rIsLPRing(const ring r)
412{
413 assume(r != NULL);
414#ifdef HAVE_SHIFTBBA
415 return (r->isLPring!=0);
416#else
417 return FALSE;
418#endif
419}
420
421static inline BOOLEAN rIsNCRing(const ring r)
422{
423 assume(r != NULL);
424 return rIsPluralRing(r) || rIsLPRing(r);
425}
426
427static inline BOOLEAN rIsRatGRing(const ring r)
428{
429 assume(r != NULL);
430#ifdef HAVE_PLURAL
431 /* nc_struct *n; */
432 return (r != NULL) /* && ((n=r->GetNC()) != NULL) */
433 && (r->real_var_start>1);
434#else
435 return FALSE;
436#endif
437}
438
439// The following are for LaScala3 only!
440void rChangeSComps(int* currComponents, long* currShiftedComponents, int length, ring r);
441void rGetSComps(int** currComponents, long** currShiftedComponents, int *length, ring r);
442
443
444
445const char * rSimpleOrdStr(int ord);
446rRingOrder_t rOrderName(char * ordername);
447char * rOrdStr(ring r);
448char * rVarStr(ring r);
449char * rCharStr(ring r);
450char * rString(ring r);
451int rChar(ring r);
452
453char * rParStr(ring r);
454
455int rSum(ring r1, ring r2, ring &sum);
456/// returns -1 for not compatible, 1 for compatible (and sum)
457/// dp_dp:0: block ordering, 1: dp,dp, 2: aa(...),dp
458/// vartest: check for name conflicts
459int rSumInternal(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp);
460
461/// returns TRUE, if r1 equals r2 FALSE, otherwise Equality is
462/// determined componentwise, if qr == 1, then qrideal equality is
463/// tested, as well
464BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr = TRUE);
465
466/// returns TRUE, if r1 and r2 represents the monomials in the same way
467/// FALSE, otherwise
468/// this is an analogue to rEqual but not so strict
469BOOLEAN rSamePolyRep(ring r1, ring r2);
470
471void rUnComplete(ring r);
472
473BOOLEAN rRing_has_CompLastBlock(const ring r);
474BOOLEAN rRing_ord_pure_dp(const ring r);
475BOOLEAN rRing_ord_pure_Dp(const ring r);
476BOOLEAN rRing_ord_pure_lp(const ring r);
477
478#ifdef HAVE_RINGS
479static inline BOOLEAN rField_is_Ring_2toM(const ring r)
480{ assume(r != NULL); assume(r->cf != NULL); return ( nCoeff_is_Ring_2toM(r->cf) ); }
481
482static inline BOOLEAN rField_is_Ring_PtoM(const ring r)
483{ assume(r != NULL); assume(r->cf != NULL); return ( nCoeff_is_Ring_PtoM(r->cf) ); }
484
485#define rField_is_Ring(R) nCoeff_is_Ring((R)->cf)
486
487static inline BOOLEAN rField_is_Domain(const ring r)
488{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Domain(r->cf); }
489
490static inline BOOLEAN rField_has_Units(const ring r)
491{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_has_Units(r->cf); }
492#else
493#define rField_is_Ring(A) (0)
494#define rField_is_Ring_2toM(A) (0)
495#define rField_is_Ring_PtoM(A) (0)
496#define rField_is_Domain(A) (1)
497#define rField_has_Units(A) (1)
498#endif
499
500static inline BOOLEAN rField_is_Zp(const ring r)
501{ assume(r != NULL); assume(r->cf != NULL); return (getCoeffType(r->cf) == n_Zp); }
502
503static inline BOOLEAN rField_is_Zp(const ring r, int p)
504{ assume(r != NULL); assume(r->cf != NULL); return (getCoeffType(r->cf) == n_Zp) && (r->cf->ch == p); }
505
506static inline BOOLEAN rField_is_Q(const ring r)
507{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Q(r->cf); }
508
509static inline BOOLEAN rField_is_Z(const ring r)
510{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Z(r->cf); }
511
512static inline BOOLEAN rField_is_Zn(const ring r)
513{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Zn(r->cf); }
514
515static inline BOOLEAN rField_is_numeric(const ring r) /* R, long R, long C */
516{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_numeric(r->cf); }
517
518static inline BOOLEAN rField_is_R(const ring r)
519{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_R(r->cf); }
520
521static inline BOOLEAN rField_is_GF(const ring r)
522{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_GF(r->cf); }
523
524static inline BOOLEAN rField_is_GF(const ring r, int q)
525{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_GF(r->cf, q); }
526
527/* DO NOT USE; just here for compatibility reasons towards
528 the SINGULAR svn trunk */
529static inline BOOLEAN rField_is_Zp_a(const ring r)
530{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Zp_a(r->cf); }
531
532/* DO NOT USE; just here for compatibility reasons towards
533 the SINGULAR svn trunk */
534static inline BOOLEAN rField_is_Zp_a(const ring r, int p)
535{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Zp_a(r->cf, p); }
536
537/* DO NOT USE; just here for compatibility reasons towards
538 the SINGULAR svn trunk */
539static inline BOOLEAN rField_is_Q_a(const ring r)
540{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_Q_a(r->cf); }
541
542static inline BOOLEAN rField_is_long_R(const ring r)
543{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_long_R(r->cf); }
544
545static inline BOOLEAN rField_is_long_C(const ring r)
546{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_is_long_C(r->cf); }
547
548static inline BOOLEAN rField_has_simple_inverse(const ring r)
549{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_has_simple_inverse(r->cf); }
550
551/// Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies
552static inline BOOLEAN rField_has_simple_Alloc(const ring r)
553{ assume(r != NULL); assume(r->cf != NULL); return nCoeff_has_simple_Alloc(r->cf); }
554
555/// the type of the coefficient filed of r (n_Zp, n_Q, etc)
556static inline n_coeffType rFieldType(const ring r) { return (r->cf->type); }
557
558/// this needs to be called whenever a new ring is created: new fields
559/// in ring are created (like VarOffset), unless they already exist
560/// with force == 1, new fields are _always_ created (overwritten),
561/// even if they exist
562BOOLEAN rComplete(ring r, int force = 0);
563// use this to free fields created by rComplete //?
564
565/// set all properties of a new ring - also called by rComplete
566void p_SetGlobals(const ring r, BOOLEAN complete = TRUE);
567
568static inline int rBlocks(const ring r)
569{
570 assume(r != NULL);
571 int i=0;
572 while (r->order[i]!=0) i++;
573 return i+1;
574}
575
576// misc things
577static inline char* rRingVar(short i, const ring r)
578{
579 assume(r != NULL); assume(r->cf != NULL); return r->names[i];
580}
581static inline BOOLEAN rShortOut(const ring r)
582{
583 assume(r != NULL); return (r->ShortOut);
584}
585
586static inline BOOLEAN rCanShortOut(const ring r)
587{
588 assume(r != NULL); return (r->CanShortOut);
589}
590
591/// #define rVar(r) (r->N)
592static inline short rVar(const ring r)
593{
594 assume(r != NULL);
595 return r->N;
596}
597
598/// (r->cf->P)
599static inline int rPar(const ring r)
600{
601 assume(r != NULL);
602 const coeffs C = r->cf;
603 assume(C != NULL);
604
605 return n_NumberOfParameters(C);
606// if( nCoeff_is_Extension(C) )
607// {
608// const ring R = C->extRing;
609// assume( R != NULL );
610// return rVar( R );
611// }
612// else if (nCoeff_is_GF(C))
613// {
614// return 1;
615// }
616// else if (nCoeff_is_long_C(C))
617// {
618// return 1;
619// }
620// return 0;
621}
622
623
624/// (r->cf->parameter)
625static inline char const ** rParameter(const ring r)
626{
627 assume(r != NULL);
628 const coeffs C = r->cf;
629 assume(C != NULL);
630
631 return n_ParameterNames(C);
632// if( nCoeff_is_Extension(C) ) // only alg / trans. exts...
633// {
634// const ring R = C->extRing;
635// assume( R != NULL );
636// return R->names;
637// }
638// else if (nCoeff_is_GF(C))
639// {
640// return &(C->m_nfParameter);
641// }
642// else if (nCoeff_is_long_C(C))
643// {
644// return &(C->complex_parameter);
645// }
646// return NULL;
647}
648
649/// return the specified parameter as a (new!) number in the given
650/// polynomial ring, or NULL if invalid
651/// parameters (as variables) begin with 1!
652static inline number n_Param(const short iParameter, const ring r)
653{
654 assume(r != NULL);
655 const coeffs C = r->cf;
656 assume(C != NULL);
657 return n_Param(iParameter, C);
658// const n_coeffType _filed_type = getCoeffType(C);
659//
660// if ( iParameter <= 0 || iParameter > rPar(r) )
661// // Wrong parameter
662// return NULL;
663//
664// if( _filed_type == n_algExt )
665// return naParameter(iParameter, C);
666//
667// if( _filed_type == n_transExt )
668// return ntParameter(iParameter, C);
669//
670// if (_filed_type == n_GF)// if (nCoeff_is_GF(C))
671// {
672// number nfPar (int i, const coeffs);
673// return nfPar(iParameter, C);
674// }
675//
676// if (_filed_type == n_long_C) // if (nCoeff_is_long_C(C))
677// {
678// number ngcPar(int i, const coeffs r);
679// return ngcPar(iParameter, C);
680// }
681//
682// return NULL;
683}
684
685/// if m == var(i)/1 => return i,
686int n_IsParam(number m, const ring r);
687
688//#define rInternalChar(r) ((r)->cf->ch)
689static inline int rInternalChar(const ring r)
690{
691 assume(r != NULL);
692 const coeffs C = r->cf;
693 assume(C != NULL);
694 return C->ch;
695}
696
697
698/// Tests whether '(r->cf->minpoly) == NULL'
699static inline BOOLEAN rMinpolyIsNULL(const ring r)
700{
701 assume(r != NULL);
702 const coeffs C = r->cf;
703 assume(C != NULL);
704
705 const BOOLEAN ret = nCoeff_is_algExt(C); // || nCoeff_is_GF(C) || nCoeff_is_long_C(C);
706
707 if( ret )
708 {
709 assume( (C->extRing) != NULL );
710 BOOLEAN idIs0 (ideal h);
711 assume((!((C->extRing)->qideal==NULL)) && (!idIs0((C->extRing)->qideal)));
712 }
713
714 // TODO: this leads to test fails (due to rDecompose?)
715 return !ret;
716}
717
718
719
720static inline BOOLEAN rIsSyzIndexRing(const ring r)
721{ assume(r != NULL); assume(r->cf != NULL); return r->order[0] == ringorder_s;}
722
723static inline int rGetCurrSyzLimit(const ring r)
724{ assume(r != NULL); assume(r->cf != NULL); return (rIsSyzIndexRing(r)? r->typ[0].data.syz.limit : 0);}
725
726void rSetSyzComp(int k, const ring r);
727
728// Ring Manipulations
729ring rAssure_HasComp(const ring r);
730ring rAssure_SyzOrder(const ring r, BOOLEAN complete);
731ring rAssure_SyzComp(const ring r, BOOLEAN complete = TRUE);
732ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete = TRUE, int sgn = 1);
733
734ring rAssure_dp_S(const ring r);
735ring rAssure_dp_C(const ring r);
736ring rAssure_C_dp(const ring r);
737ring rAssure_c_dp(const ring r);
738
739/// makes sure that c/C ordering is last ordering
740ring rAssure_CompLastBlock(const ring r, BOOLEAN complete = TRUE);
741
742/// makes sure that c/C ordering is last ordering and SyzIndex is first
743ring rAssure_SyzComp_CompLastBlock(const ring r);
744ring rAssure_TDeg(const ring r, int &pos);
745
746/// return the max-comonent wchich has syzIndex i
747/// Assume: i<= syzIndex_limit
748int rGetMaxSyzComp(int i, const ring r);
749
750BOOLEAN rHasSimpleOrder(const ring r);
751BOOLEAN rHas_c_Ordering(const ring r);
752
753/// returns TRUE, if simple lp or ls ordering
754BOOLEAN rHasSimpleLexOrder(const ring r);
755
756//???? return TRUE if p->exp[r->pOrdIndex] holds total degree of p ???
757
758
759inline BOOLEAN rHasGlobalOrdering(const ring r){ return (r->OrdSgn==1); }
760inline BOOLEAN rHasLocalOrMixedOrdering(const ring r){ return (r->OrdSgn==-1); }
761inline BOOLEAN rHasMixedOrdering(const ring r) { return (r->MixedOrder); }
762
763// #define rHasGlobalOrdering(R) ((R)->OrdSgn==1)
764// #define rHasLocalOrMixedOrdering(R) ((R)->OrdSgn==-1)
765
767
768/// return TRUE if p_SetComp requires p_Setm
771
772static inline BOOLEAN rOrd_is_Comp_dp(const ring r)
773{
774 assume(r != NULL);
775 assume(r->cf != NULL);
776 return ((r->order[0] == ringorder_c || r->order[0] == ringorder_C) &&
777 r->order[1] == ringorder_dp &&
778 r->order[2] == 0);
779}
780
781#ifdef RDEBUG
782#define rTest(r) rDBTest(r, __FILE__, __LINE__)
783extern BOOLEAN rDBTest(ring r, const char* fn, const int l);
784#else
785#define rTest(r) (TRUE)
786#endif
787
788ring rModifyRing(ring r, BOOLEAN omit_degree,
789 BOOLEAN omit_comp,
790 unsigned long exp_limit);
791
792/// construct Wp, C ring
793ring rModifyRing_Wp(ring r, int* weights);
794
795void rKillModifiedRing(ring r);
796// also frees weights
797void rKillModified_Wp_Ring(ring r);
798
799ring rModifyRing_Simple(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit, BOOLEAN &simple);
800
801#ifdef RDEBUG
802void rDebugPrint(const ring r);
803// void pDebugPrint(poly p);
804void p_DebugPrint(poly p, const ring r);
805#endif
806
807int64 * rGetWeightVec(const ring r);
808void rSetWeightVec(ring r, int64 *wv);
809
810/////////////////////////////
811// Auxillary functions
812//
813
814/* return the varIndex-th ring variable as a poly;
815 varIndex starts at index 1 */
816poly rGetVar(const int varIndex, const ring r);
817
818BOOLEAN rSetISReference(const ring r, const ideal F, const int i = 0, const int p = 0);
819
820/// return the position of the p^th IS block order block in r->typ[]...
821int rGetISPos(const int p, const ring r);
822
823BOOLEAN rCheckIV(const intvec *iv);
824int rTypeOfMatrixOrder(const intvec *order);
825
826void rDelete(ring r); // To be used instead of rKill!
827
829
830// ring manipulation
831/// K[x],"y" -> K[x,y] resp. K[y,x]
832ring rPlusVar(const ring r, char *v,int left);
833
834/// undo rPlusVar
835ring rMinusVar(const ring r, char *v);
836
837static inline ring rIncRefCnt(ring r) { r->ref++; return r; }
838static inline void rDecRefCnt(ring r) { r->ref--; }
839#endif
int sgn(const Rational &a)
Definition: GMPrat.cc:430
All the auxiliary stuff.
long int64
Definition: auxiliary.h:68
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
int p
Definition: cfModGcd.cc:4078
CanonicalForm cf
Definition: cfModGcd.cc:4083
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
Definition: cf_map_ext.cc:504
Definition: idrec.h:35
Definition: intvec.h:23
Coefficient rings, fields and other domains suitable for Singular polynomials.
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
Definition: coeffs.h:794
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:836
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:813
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:888
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:724
n_coeffType
Definition: coeffs.h:27
@ n_Zp
\F{p < 2^31}
Definition: coeffs.h:29
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:829
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
Definition: coeffs.h:736
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:856
static FORCE_INLINE BOOLEAN nCoeff_has_simple_inverse(const coeffs r)
TRUE, if the computation of the inverse is fast, i.e. prefer leading coeff. 1 over content.
Definition: coeffs.h:899
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:775
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:803
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete is empty operation.
Definition: coeffs.h:903
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
Definition: coeffs.h:823
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:771
static FORCE_INLINE BOOLEAN nCoeff_is_Q_a(const coeffs r)
Definition: coeffs.h:882
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:721
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:907
static FORCE_INLINE BOOLEAN nCoeff_is_R(const coeffs r)
Definition: coeffs.h:833
static FORCE_INLINE BOOLEAN nCoeff_is_long_C(const coeffs r)
Definition: coeffs.h:891
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
#define const
Definition: fegetopt.c:39
#define EXTERN_VAR
Definition: globaldefs.h:6
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
STATIC_VAR Poly * h
Definition: janet.cc:971
#define assume(x)
Definition: mod2.h:389
The main handler for Singular numbers which are suitable for Singular polynomials.
Definition: qr.h:46
#define NULL
Definition: omList.c:12
omBin_t * omBin
Definition: omStructs.h:12
BOOLEAN rOrd_SetCompRequiresSetm(const ring r)
return TRUE if p_SetComp requires p_Setm
Definition: ring.cc:1993
ring rOpposite(ring r)
Definition: ring.cc:5281
static BOOLEAN rField_is_R(const ring r)
Definition: ring.h:518
int rSum(ring r1, ring r2, ring &sum)
Definition: ring.cc:1402
short place
Definition: ring.h:134
int * weights_m
Definition: ring.h:140
short end
Definition: ring.h:136
int n_IsParam(number m, const ring r)
if m == var(i)/1 => return i,
Definition: ring.cc:5773
BOOLEAN rComplete(ring r, int force=0)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3450
int * Components
Definition: ring.h:170
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
Definition: ring.cc:4414
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:529
BOOLEAN rRing_ord_pure_Dp(const ring r)
Definition: ring.cc:5202
ring rModifyRing_Wp(ring r, int *weights)
construct Wp, C ring
Definition: ring.cc:2945
short end
Definition: ring.h:151
short place
Definition: ring.h:159
short place
Definition: ring.h:149
void rSetWeightVec(ring r, int64 *wv)
Definition: ring.cc:5232
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:509
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:500
short start
Definition: ring.h:125
int r_IsRingVar(const char *n, char **names, int N)
Definition: ring.cc:212
struct p_Procs_s p_Procs_s
Definition: ring.h:23
int rGetISPos(const int p, const ring r)
return the position of the p^th IS block order block in r->typ[]...
Definition: ring.cc:5000
static BOOLEAN rField_is_Ring_PtoM(const ring r)
Definition: ring.h:482
short place
Definition: ring.h:124
short start
Definition: ring.h:196
BOOLEAN rHasSimpleLexOrder(const ring r)
returns TRUE, if simple lp or ls ordering
Definition: ring.cc:1919
void p_DebugPrint(poly p, const ring r)
Definition: ring.cc:4327
void rKillModifiedRing(ring r)
Definition: ring.cc:3059
void(* p_SetmProc)(poly p, const ring r)
Definition: ring.h:39
BOOLEAN rRing_ord_pure_dp(const ring r)
Definition: ring.cc:5192
short end
Definition: ring.h:117
static n_coeffType rFieldType(const ring r)
the type of the coefficient filed of r (n_Zp, n_Q, etc)
Definition: ring.h:556
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
static BOOLEAN rField_is_long_C(const ring r)
Definition: ring.h:545
ro_typ ord_typ
Definition: ring.h:220
int * pVarOffset
Definition: ring.h:198
static BOOLEAN rOrd_is_Comp_dp(const ring r)
Definition: ring.h:772
const char * rSimpleOrdStr(int ord)
Definition: ring.cc:77
ring rAssure_CompLastBlock(const ring r, BOOLEAN complete=TRUE)
makes sure that c/C ordering is last ordering
Definition: ring.cc:4694
ring rCopy0AndAddA(ring r, int64vec *wv64, BOOLEAN copy_qideal=TRUE, BOOLEAN copy_ordering=TRUE)
Definition: ring.cc:1564
ideal(* BBA_Proc)(const ideal, const ideal, const intvec *, const intvec *, kStrategy strat, const ring)
Definition: ring.h:244
int * weights
Definition: ring.h:138
static int rBlocks(const ring r)
Definition: ring.h:568
ring rAssure_c_dp(const ring r)
Definition: ring.cc:4990
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:38
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:723
rOrderType_t rGetOrderType(ring r)
Definition: ring.cc:1840
int rChar(ring r)
Definition: ring.cc:713
int rTypeOfMatrixOrder(const intvec *order)
Definition: ring.cc:185
void rUnComplete(ring r)
Definition: ring.cc:3965
static ring rIncRefCnt(ring r)
Definition: ring.h:837
char * rCharStr(ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition: ring.cc:647
ring rModifyRing_Simple(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit, BOOLEAN &simple)
Definition: ring.cc:2993
void rKillModified_Wp_Ring(ring r)
Definition: ring.cc:3069
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:487
int curr_index
Definition: ring.h:183
ring rMinusVar(const ring r, char *v)
undo rPlusVar
Definition: ring.cc:5876
short place
Definition: ring.h:115
BOOLEAN rRing_has_CompLastBlock(const ring r)
Definition: ring.cc:5185
short place
Definition: ring.h:180
long(* pLDegProc)(poly p, int *length, ring r)
Definition: ring.h:37
kBucket * kBucket_pt
Definition: ring.h:25
BOOLEAN rOrd_is_Totaldegree_Ordering(const ring r)
Definition: ring.cc:2013
static BOOLEAN rIsRatGRing(const ring r)
Definition: ring.h:427
static BOOLEAN rField_is_Zn(const ring r)
Definition: ring.h:512
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:599
ring rAssure_SyzOrder(const ring r, BOOLEAN complete)
Definition: ring.cc:4430
poly(* NF_Proc)(ideal, ideal, poly, int, int, const ring _currRing)
Definition: ring.h:243
ring rAssure_C_dp(const ring r)
Definition: ring.cc:4985
skStrategy * kStrategy
Definition: ring.h:241
BOOLEAN rSetISReference(const ring r, const ideal F, const int i=0, const int p=0)
Changes r by setting induced ordering parameters: limit and reference leading terms F belong to r,...
Definition: ring.cc:5032
BOOLEAN rHasSimpleOrder(const ring r)
Definition: ring.cc:1887
ideal F
Definition: ring.h:212
ro_typ
Definition: ring.h:51
@ ro_wp64
Definition: ring.h:55
@ ro_syz
Definition: ring.h:60
@ ro_cp
Definition: ring.h:58
@ ro_dp
Definition: ring.h:52
@ ro_is
Definition: ring.h:61
@ ro_wp_neg
Definition: ring.h:56
@ ro_wp
Definition: ring.h:53
@ ro_isTemp
Definition: ring.h:61
@ ro_am
Definition: ring.h:54
@ ro_none
Definition: ring.h:62
@ ro_syzcomp
Definition: ring.h:59
ring rAssure_SyzComp(const ring r, BOOLEAN complete=TRUE)
Definition: ring.cc:4435
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
Definition: ring.cc:5158
static int rInternalChar(const ring r)
Definition: ring.h:689
char * rString(ring r)
Definition: ring.cc:673
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:411
ring rAssure_HasComp(const ring r)
Definition: ring.cc:4625
int limit
Definition: ring.h:181
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr=TRUE)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
Definition: ring.cc:1746
rRingOrder_t
order stuff
Definition: ring.h:68
@ ringorder_lp
Definition: ring.h:77
@ ringorder_a
Definition: ring.h:70
@ ringorder_am
Definition: ring.h:88
@ ringorder_a64
for int64 weights
Definition: ring.h:71
@ ringorder_rs
opposite of ls
Definition: ring.h:92
@ ringorder_C
Definition: ring.h:73
@ ringorder_S
S?
Definition: ring.h:75
@ ringorder_ds
Definition: ring.h:84
@ ringorder_Dp
Definition: ring.h:80
@ ringorder_unspec
Definition: ring.h:94
@ ringorder_L
Definition: ring.h:89
@ ringorder_Ds
Definition: ring.h:85
@ ringorder_dp
Definition: ring.h:78
@ ringorder_c
Definition: ring.h:72
@ ringorder_rp
Definition: ring.h:79
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition: ring.h:91
@ ringorder_no
Definition: ring.h:69
@ ringorder_Wp
Definition: ring.h:82
@ ringorder_ws
Definition: ring.h:86
@ ringorder_Ws
Definition: ring.h:87
@ ringorder_IS
Induced (Schreyer) ordering.
Definition: ring.h:93
@ ringorder_ls
Definition: ring.h:83
@ ringorder_s
s?
Definition: ring.h:76
@ ringorder_wp
Definition: ring.h:81
@ ringorder_M
Definition: ring.h:74
static BOOLEAN rField_is_Q_a(const ring r)
Definition: ring.h:539
ring rCopy0(const ring r, BOOLEAN copy_qideal=TRUE, BOOLEAN copy_ordering=TRUE)
Definition: ring.cc:1421
static char * rRingVar(short i, const ring r)
Definition: ring.h:577
BOOLEAN rHas_c_Ordering(const ring r)
Definition: ring.cc:1883
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:506
ring rEnvelope(ring r)
Definition: ring.cc:5671
int limit
Definition: ring.h:209
void rDebugPrint(const ring r)
Definition: ring.cc:4122
void rWrite(ring r, BOOLEAN details=FALSE)
Definition: ring.cc:226
static BOOLEAN rField_has_Units(const ring r)
Definition: ring.h:490
static BOOLEAN rShortOut(const ring r)
Definition: ring.h:581
BOOLEAN rRing_ord_pure_lp(const ring r)
Definition: ring.cc:5212
poly rGetVar(const int varIndex, const ring r)
Definition: ring.cc:5763
rOrderType_t
Definition: ring.h:98
@ rOrderType_Syz
syzygy ordering
Definition: ring.h:105
@ rOrderType_Syz2dpc
syzcomp2dpc
Definition: ring.h:107
@ 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_Schreyer
Schreyer ordering.
Definition: ring.h:106
@ rOrderType_ExpNoComp
simple ordering, differences in component are not considered
Definition: ring.h:108
@ rOrderType_ExpComp
simple ordering, exponent vector has priority component not compatible with exp-vector order
Definition: ring.h:101
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
Definition: ring.cc:4405
EXTERN_VAR omBin sip_sring_bin
Definition: ring.h:828
long * ShiftedComponents
Definition: ring.h:169
static BOOLEAN rField_has_simple_Alloc(const ring r)
Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies.
Definition: ring.h:552
short end
Definition: ring.h:206
static BOOLEAN rIsNCRing(const ring r)
Definition: ring.h:421
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
static void rDecRefCnt(ring r)
Definition: ring.h:838
static char const ** rParameter(const ring r)
(r->cf->parameter)
Definition: ring.h:625
ring rModifyRing(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit)
Definition: ring.cc:2698
ring rAssure_SyzComp_CompLastBlock(const ring r)
makes sure that c/C ordering is last ordering and SyzIndex is first
Definition: ring.cc:4749
char * rParStr(ring r)
Definition: ring.cc:649
int * syz_index
Definition: ring.h:182
BOOLEAN rCheckIV(const intvec *iv)
Definition: ring.cc:175
short end
Definition: ring.h:161
short start
Definition: ring.h:135
static BOOLEAN rField_is_long_R(const ring r)
Definition: ring.h:542
rRingOrder_t rOrderName(char *ordername)
Definition: ring.cc:507
short end
Definition: ring.h:126
short len_gen
Definition: ring.h:137
short start
Definition: ring.h:150
short start
Definition: ring.h:116
char * rOrdStr(ring r)
Definition: ring.cc:521
static BOOLEAN rField_is_numeric(const ring r)
Definition: ring.h:515
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:450
ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete=TRUE, int sgn=1)
Definition: ring.cc:4850
int64 * weights64
Definition: ring.h:152
short start
Definition: ring.h:160
BOOLEAN rHasMixedOrdering(const ring r)
Definition: ring.h:761
int order_index
Definition: ring.h:221
char * rVarStr(ring r)
Definition: ring.cc:623
void p_SetGlobals(const ring r, BOOLEAN complete=TRUE)
set all properties of a new ring - also called by rComplete
Definition: ring.cc:3415
ring rPlusVar(const ring r, char *v, int left)
K[x],"y" -> K[x,y] resp. K[y,x].
Definition: ring.cc:5794
short start
Definition: ring.h:206
static BOOLEAN rCanShortOut(const ring r)
Definition: ring.h:586
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:720
int * weights
Definition: ring.h:127
static BOOLEAN rMinpolyIsNULL(const ring r)
Tests whether '(r->cf->minpoly) == NULL'.
Definition: ring.h:699
ring rDefault(int ch, int N, char **n)
Definition: ring.cc:155
int * pVarOffset
Definition: ring.h:207
short place
Definition: ring.h:168
static BOOLEAN rField_is_Ring_2toM(const ring r)
Definition: ring.h:479
poly(* pShallowCopyDeleteProc)(poly s_p, ring source_r, ring dest_r, omBin dest_bin)
returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == de...
Definition: ring.h:44
static number n_Param(const short iParameter, const ring r)
return the specified parameter as a (new!) number in the given polynomial ring, or NULL if invalid pa...
Definition: ring.h:652
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:521
int suffixpos
Definition: ring.h:197
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:592
ring rAssure_dp_S(const ring r)
Definition: ring.cc:4975
ring rAssure_TDeg(const ring r, int &pos)
Definition: ring.cc:4527
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
BOOLEAN rHasGlobalOrdering(const ring r)
Definition: ring.h:759
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:760
union sro_ord::@1 data
void rSetSyzComp(int k, const ring r)
Definition: ring.cc:5086
long length
Definition: ring.h:172
int64 * rGetWeightVec(const ring r)
Definition: ring.cc:5222
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:548
ring rAssure_dp_C(const ring r)
Definition: ring.cc:4980
ring rCopy(ring r)
Definition: ring.cc:1731
idrec * idhdl
Definition: ring.h:21
BOOLEAN rDBTest(ring r, const char *fn, const int l)
Definition: ring.cc:2038
unsigned long rGetExpSize(unsigned long bitmask, int &bits, int N)
Definition: ring.cc:2663
Definition: ring.h:205
Definition: ring.h:133
Definition: ring.h:158
Definition: ring.h:114
Definition: ring.h:219
Definition: ring.h:179
Definition: ring.h:123
Definition: ring.h:148
The following sip_sideal structure has many different uses thoughout Singular. Basic use-cases for it...
Definition: simpleideals.h:18
Definition: ring.h:248
poly ppNoether
Definition: ring.h:287
n_Procs_s * cf
Definition: ring.h:368
short ExpPerLong
Definition: ring.h:335
int * block0
Definition: ring.h:254
int * NegWeightL_Offset
Definition: ring.h:269
p_SetmProc p_Setm
Definition: ring.h:367
BOOLEAN pLexOrder
Definition: ring.h:322
void * ext_ref
Definition: ring.h:289
short pCompIndex
Definition: ring.h:336
short pOrdIndex
Definition: ring.h:337
pFDegProc pFDegOrig
Definition: ring.h:363
short N
Definition: ring.h:303
int * firstwv
Definition: ring.h:283
short VarL_Size
Definition: ring.h:333
intvec * pModW
Definition: ring.h:286
const nc_struct * GetNC() const
Definition: ring.h:373
short LPncGenCount
Definition: ring.h:314
int * block1
Definition: ring.h:255
short real_var_end
Definition: ring.h:309
short firstBlockEnds
Definition: ring.h:307
BOOLEAN CanShortOut
Definition: ring.h:319
rRingOrder_t * order
Definition: ring.h:253
short NegWeightL_Size
Definition: ring.h:344
unsigned long options
Definition: ring.h:298
pFDegProc pFDeg
Definition: ring.h:359
unsigned long wanted_maxExp
Definition: ring.h:352
int * VarL_Offset
Definition: ring.h:347
omBin PolyBin
Definition: ring.h:285
nc_struct * _nc
Definition: ring.h:371
int * VarOffset
Definition: ring.h:271
short CmpL_Size
Definition: ring.h:329
BOOLEAN ComponentOrder
Definition: ring.h:324
idhdl idroot
Definition: ring.h:252
BOOLEAN MixedOrder
Definition: ring.h:321
long * ordsgn
Definition: ring.h:261
short VarL_LowIndex
Definition: ring.h:342
int ** wvhdl
Definition: ring.h:257
BOOLEAN LexOrder
Definition: ring.h:320
unsigned long divmask
Definition: ring.h:354
p_Procs_s * p_Procs
Definition: ring.h:356
unsigned long bitmask
Definition: ring.h:350
ideal qideal
extension to the ring structure: qring, rInit, OR for Q_a/Zp_a, rInit (replaces minideal!...
Definition: ring.h:275
pLDegProc pLDeg
Definition: ring.h:360
short real_var_start
Definition: ring.h:309
sro_ord * typ
Definition: ring.h:265
char ** names
Definition: ring.h:258
BOOLEAN ShortOut
Definition: ring.h:318
short isLPring
Definition: ring.h:313
pLDegProc pLDegOrig
Definition: ring.h:365
BOOLEAN VectorOut
Definition: ring.h:317
short BitsPerExp
Definition: ring.h:334
short ExpL_Size
Definition: ring.h:328
nc_struct *& GetNC()
Definition: ring.h:374
short OrdSize
Definition: ring.h:338
short OrdSgn
Definition: ring.h:305
int ref
Definition: ring.h:301
Definition: nc.h:68
EXTERN_VAR long * currShiftedComponents
Definition: syz.h:118