source: git/kernel/ring.h @ 19370c

spielwiese
Last change on this file since 19370c was 86016d, checked in by Motsak Oleksandr <motsak@…>, 17 years ago
*motsak: !+!: factors of SCA, debug print for SCA, "kill squares" in std. * : ncRingType, naming, formatting, unified NC setup. git-svn-id: file:///usr/local/Singular/svn/trunk@9792 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 10.3 KB
Line 
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/* $Id: ring.h,v 1.17 2007-01-31 23:51:25 motsak Exp $ */
10
11/* includes */
12#include "structs.h"
13#include "structs.h"  // we need ABS
14#include "polys-impl.h"
15
16#define SHORT_REAL_LENGTH 6 // use short reals for real <= 6 digits
17
18
19void   rChangeCurrRing(ring r);
20void   rSetHdl(idhdl h);
21ring   rInit(sleftv* pn, sleftv* rv, sleftv* ord);
22idhdl  rDefault(char *s);
23ring   rDefault(int ch, int N, char **n);
24#define rIsRingVar(A) r_IsRingVar(A,currRing)
25int    r_IsRingVar(const char *n, ring r);
26void   rWrite(ring r);
27void   rKill(idhdl h);
28void   rKill(ring r);
29ring   rCopy(ring r);
30ring rCopy0(ring r, BOOLEAN copy_qideal = TRUE, BOOLEAN copy_ordering = TRUE);
31void   rNameCheck(ring R);
32ring   rOpposite(ring r);
33ring   rEnvelope(ring r);
34
35// we must always have this test!
36inline bool rIsPluralRing(const ring r)
37{
38#ifdef HAVE_PLURAL
39  return (r != NULL) && (r->nc != NULL) && (r->nc->type != nc_error); 
40#else
41  return false;
42#endif
43}
44
45
46
47
48#ifdef PDEBUG
49#define rChangeSComps(c,s,l) rDBChangeSComps(c,s,l)
50#define rGetSComps(c,s,l) rDBGetSComps(c,s,l)
51void rDBChangeSComps(int* currComponents,
52                     long* currShiftedComponents,
53                     int length,
54                     ring r = currRing);
55void rDBGetSComps(int** currComponents,
56                  long** currShiftedComponents,
57                  int *length,
58                  ring r = currRing);
59#else
60#define rChangeSComps(c,s,l) rNChangeSComps(c,s)
61#define rGetSComps(c,s,l) rNGetSComps(c,s)
62#endif
63
64void rNChangeSComps(int* currComponents, long* currShiftedComponents, ring r = currRing);
65void rNGetSComps(int** currComponents, long** currShiftedComponents, ring r = currRing);
66
67idhdl  rFindHdl(ring r, idhdl n, idhdl w);
68idhdl rSimpleFindHdl(ring r, idhdl root, idhdl n);
69const char * rSimpleOrdStr(int ord);
70int rOrderName(char * ordername);
71char * rOrdStr(ring r);
72char * rVarStr(ring r);
73char * rCharStr(ring r);
74char * rString(ring r);
75int    rChar(ring r=currRing);
76#define rPar(r) (r->P)
77#define rVar(r) (r->N)
78char * rParStr(ring r);
79int    rIsExtension(ring r);
80int    rIsExtension();
81int    rSum(ring r1, ring r2, ring &sum);
82
83BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr = 1);
84void   rUnComplete(ring r);
85
86#define  rInternalChar(r) ((r)->ch)
87
88BOOLEAN rRing_is_Homog(ring r=currRing);
89BOOLEAN rRing_has_CompLastBlock(ring r=currRing);
90
91#ifdef HAVE_RING2TOM
92inline BOOLEAN rField_is_Ring_2toM(ring r=currRing)
93{ return (r->cring == 1); }
94
95inline BOOLEAN rField_is_Zp(ring r=currRing)
96{ return (r->cring == 0) && (r->ch > 1) && (r->parameter==NULL); }
97
98inline BOOLEAN rField_is_Zp(ring r, int p)
99{ return (r->cring == 0) && (r->ch > 1 && r->ch == ABS(p) && r->parameter==NULL); }
100
101inline BOOLEAN rField_is_Q(ring r=currRing)
102{ return (r->cring == 0) && (r->ch == 0) && (r->parameter==NULL); }
103
104inline BOOLEAN rField_is_numeric(ring r=currRing) /* R, long R, long C */
105{ return (r->cring == 0) && (r->ch ==  -1); }
106
107inline BOOLEAN rField_is_R(ring r=currRing)
108{
109  if (rField_is_numeric(r) && (r->float_len <= (short)SHORT_REAL_LENGTH))
110    return (r->cring == 0) && (r->parameter==NULL);
111  return FALSE;
112}
113
114inline BOOLEAN rField_is_GF(ring r=currRing)
115{ return (r->cring == 0) && (r->ch > 1) && (r->parameter!=NULL); }
116
117inline BOOLEAN rField_is_GF(ring r, int q)
118{ return (r->cring == 0) && (r->ch == q); }
119
120inline BOOLEAN rField_is_Zp_a(ring r=currRing)
121{ return (r->cring == 0) && (r->ch < -1); }
122
123inline BOOLEAN rField_is_Zp_a(ring r, int p)
124{ return (r->cring == 0) && (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
125
126inline BOOLEAN rField_is_Q_a(ring r=currRing)
127{ return (r->cring == 0) && (r->ch == 1); }
128
129inline BOOLEAN rField_is_long_R(ring r=currRing)
130{
131  if (rField_is_numeric(r) && (r->float_len >(short)SHORT_REAL_LENGTH))
132    return (r->cring == 0) && (r->parameter==NULL);
133  return FALSE;
134}
135
136inline BOOLEAN rField_is_long_C(ring r=currRing)
137{
138  if (rField_is_numeric(r))
139    return (r->cring == 0) && (r->parameter!=NULL);
140  return FALSE;
141}
142#else
143inline BOOLEAN rField_is_Zp(ring r=currRing)
144{ return (r->ch > 1) && (r->parameter==NULL); }
145
146inline BOOLEAN rField_is_Zp(ring r, int p)
147{ return (r->ch > 1 && r->ch == ABS(p) && r->parameter==NULL); }
148
149inline BOOLEAN rField_is_Q(ring r=currRing)
150{ return (r->ch == 0) && (r->parameter==NULL); }
151
152inline BOOLEAN rField_is_numeric(ring r=currRing) /* R, long R, long C */
153{ return (r->ch ==  -1); }
154
155inline BOOLEAN rField_is_R(ring r=currRing)
156{
157  if (rField_is_numeric(r) && (r->float_len <= (short)SHORT_REAL_LENGTH))
158    return (r->parameter==NULL);
159  return FALSE;
160}
161
162inline BOOLEAN rField_is_GF(ring r=currRing)
163{ return (r->ch > 1) && (r->parameter!=NULL); }
164
165inline BOOLEAN rField_is_GF(ring r, int q)
166{ return (r->ch == q); }
167
168inline BOOLEAN rField_is_Zp_a(ring r=currRing)
169{ return (r->ch < -1); }
170
171inline BOOLEAN rField_is_Zp_a(ring r, int p)
172{ return (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
173
174inline BOOLEAN rField_is_Q_a(ring r=currRing)
175{ return (r->ch == 1); }
176
177inline BOOLEAN rField_is_long_R(ring r=currRing)
178{
179  if (rField_is_numeric(r) && (r->float_len >(short)SHORT_REAL_LENGTH))
180    return (r->parameter==NULL);
181  return FALSE;
182}
183
184inline BOOLEAN rField_is_long_C(ring r=currRing)
185{
186  if (rField_is_numeric(r))
187    return (r->parameter!=NULL);
188  return FALSE;
189}
190#endif
191
192inline BOOLEAN rField_has_simple_inverse(ring r=currRing)
193/* { return (r->ch>1) || (r->ch== -1); } *//* Z/p, GF(p,n), R, long_R, long_C*/
194#ifdef HAVE_RING2TOM
195{ return (r->cring==1) || (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/2^n, Z/p, GF(p,n), R, long_R, long_C*/
196#else
197{ return (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/p, GF(p,n), R, long_R, long_C*/
198#endif
199
200inline BOOLEAN rField_has_simple_Alloc(ring r=currRing)
201#ifdef HAVE_RING2TOM
202{ return (rField_is_Ring_2toM(r) || rField_is_Zp(r) || rField_is_GF(r) || rField_is_R(r)); }
203#else
204{ return (rField_is_Zp(r) || rField_is_GF(r) || rField_is_R(r)); }
205#endif
206
207/* Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies*/
208inline BOOLEAN rField_is_Extension(ring r=currRing)
209{ return (rField_is_Q_a(r)) || (rField_is_Zp_a(r)); } /* Z/p(a) and Q(a)*/
210
211n_coeffType rFieldType(ring r);
212
213// this needs to be called whenever a new ring is created: new fields
214// in ring are created (like VarOffset), unless they already exist
215// with force == 1, new fields are _always_ created (overwritten),
216// even if they exist
217BOOLEAN rComplete(ring r, int force = 0);
218// use this to free fields created by rComplete
219
220BOOLEAN nc_rComplete(ring src, ring dest);
221
222void rUnComplete(ring r);
223inline int rBlocks(ring r)
224{
225  int i=0;
226  while (r->order[i]!=0) i++;
227  return i+1;
228}
229
230// misc things
231inline char* rRingVar(short i)
232{
233  return currRing->names[i];
234}
235inline char* rRingVar(short i, ring r)
236{
237  return r->names[i];
238}
239inline BOOLEAN rShortOut(ring r)
240{
241  return (r->ShortOut);
242}
243
244// order stuff
245typedef enum rRingOrder_t
246{
247  ringorder_no = 0,
248  ringorder_a,
249  ringorder_a64, // for int64 weights
250  ringorder_c,
251  ringorder_C,
252  ringorder_M,
253  ringorder_S,
254  ringorder_s,
255  ringorder_lp,
256  ringorder_dp,
257  ringorder_rp,
258  ringorder_Dp,
259  ringorder_wp,
260  ringorder_Wp,
261  ringorder_ls,
262  ringorder_ds,
263  ringorder_Ds,
264  ringorder_ws,
265  ringorder_Ws,
266  ringorder_L,
267  // the following are only used internally
268  ringorder_aa, // for idElimination, like a, except pFDeg, pWeigths ignore it
269  ringorder_unspec
270} rRingOrder_t;
271
272typedef enum rOrderType_t
273{
274  rOrderType_General = 0, // non-simple ordering as specified by currRing
275  rOrderType_CompExp,     // simple ordering, component has priority
276  rOrderType_ExpComp,     // simple ordering, exponent vector has priority
277                          // component not compatible with exp-vector order
278  rOrderType_Exp,         // simple ordering, exponent vector has priority
279                          // component is compatible with exp-vector order
280  rOrderType_Syz,         // syzygy ordering
281  rOrderType_Schreyer,    // Schreyer ordering
282  rOrderType_Syz2dpc,     // syzcomp2dpc
283  rOrderType_ExpNoComp    // simple ordering, differences in component are
284                          // not considered
285} rOrderType_t;
286
287inline BOOLEAN rIsSyzIndexRing(ring r)
288{ return r->order[0] == ringorder_s;}
289
290inline int rGetCurrSyzLimit(ring r = currRing)
291{ return (r->order[0] == ringorder_s ?
292          r->typ[0].data.syz.limit : 0);}
293
294// Ring Manipulations
295ring   rCurrRingAssure_SyzComp();
296void   rSetSyzComp(int k);
297ring   rCurrRingAssure_dp_S();
298ring   rCurrRingAssure_dp_C();
299ring   rCurrRingAssure_C_dp();
300// makes sure that c/C ordering is last ordering
301ring   rCurrRingAssure_CompLastBlock();
302// makes sure that c/C ordering is last ordering and SyzIndex is first
303ring   rCurrRingAssure_SyzComp_CompLastBlock();
304
305// return the max-comonent wchich has syzIndex i
306// Assume: i<= syzIndex_limit
307int rGetMaxSyzComp(int i);
308
309BOOLEAN rHasSimpleOrder(ring r);
310// returns TRUE, if simple lp or ls ordering
311BOOLEAN rHasSimpleLexOrder(ring r);
312// return TRUE if p->exp[r->pOrdIndex] holds total degree of p */
313BOOLEAN rOrd_is_Totaldegree_Ordering(ring r =currRing);
314// return TRUE if p_SetComp requires p_Setm
315BOOLEAN rOrd_SetCompRequiresSetm(ring r);
316rOrderType_t    rGetOrderType(ring r);
317/* returns TRUE if var(i) belongs to p-block */
318BOOLEAN rIsPolyVar(int i, ring r = currRing);
319
320inline BOOLEAN rOrd_is_Comp_dp(ring r)
321{
322  return ((r->order[0] == ringorder_c || r->order[0] == ringorder_C) &&
323          r->order[1] == ringorder_dp &&
324          r->order[2] == 0);
325}
326
327#ifdef RDEBUG
328#define rTest(r)    rDBTest(r, __FILE__, __LINE__)
329extern BOOLEAN rDBTest(ring r, char* fn, int l);
330#else
331#define rTest(r)
332#endif
333
334ring rModifyRing(ring r, BOOLEAN omit_degree,
335                         BOOLEAN omit_comp,
336                         unsigned long exp_limit);
337// construct Wp, C ring
338ring rModifyRing_Wp(ring r, int* weights);
339void rModify_a_to_A(ring r);
340
341void rKillModifiedRing(ring r);
342// also frees weights
343void rKillModified_Wp_Ring(ring r);
344
345ring rModifyRing_Simple(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit, BOOLEAN &simple);
346void rKillModifiedRing_Simple(ring r);
347
348void rDebugPrint(ring r);
349void pDebugPrint(poly p);
350
351int64 * rGetWeightVec(ring r);
352void rSetWeightVec(ring r, int64 *wv);
353
354lists rDecompose(const ring r);
355ring rCompose(const lists  L);
356/////////////////////////////
357// Auxillary functions
358//
359
360BOOLEAN rCheckIV(intvec *iv);
361int rTypeOfMatrixOrder(intvec * order);
362void rDelete(ring r);
363
364#endif
Note: See TracBrowser for help on using the repository browser.