source: git/kernel/ring.h @ b29153

spielwiese
Last change on this file since b29153 was 753f9d2, checked in by Hans Schönemann <hannes@…>, 15 years ago
*hannes: format git-svn-id: file:///usr/local/Singular/svn/trunk@11284 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 11.6 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.37 2009-01-06 16:56:05 Singular 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(const 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  nc_struct *n;
40  return (r != NULL) && ((n=r->GetNC()) != NULL) && (n->type != nc_error); 
41#else
42  return false;
43#endif
44}
45
46
47
48
49#ifdef PDEBUG
50#define rChangeSComps(c,s,l) rDBChangeSComps(c,s,l)
51#define rGetSComps(c,s,l) rDBGetSComps(c,s,l)
52void rDBChangeSComps(int* currComponents,
53                     long* currShiftedComponents,
54                     int length,
55                     ring r = currRing);
56void rDBGetSComps(int** currComponents,
57                  long** currShiftedComponents,
58                  int *length,
59                  ring r = currRing);
60#else
61#define rChangeSComps(c,s,l) rNChangeSComps(c,s)
62#define rGetSComps(c,s,l) rNGetSComps(c,s)
63#endif
64
65void rNChangeSComps(int* currComponents, long* currShiftedComponents, ring r = currRing);
66void rNGetSComps(int** currComponents, long** currShiftedComponents, ring r = currRing);
67
68idhdl  rFindHdl(ring r, idhdl n, idhdl w);
69idhdl rSimpleFindHdl(ring r, idhdl root, idhdl n);
70const char * rSimpleOrdStr(int ord);
71int rOrderName(char * ordername);
72char * rOrdStr(ring r);
73char * rVarStr(ring r);
74char * rCharStr(ring r);
75char * rString(ring r);
76int    rChar(ring r=currRing);
77#define rPar(r) (r->P)
78#define rVar(r) (r->N)
79char * rParStr(ring r);
80int    rIsExtension(ring r);
81int    rIsExtension();
82int    rSum(ring r1, ring r2, ring &sum);
83int rTensor(ring r1, ring r2, ring &sum, BOOLEAN vartest, BOOLEAN dp_dp);
84
85BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr = 1);
86BOOLEAN rSamePolyRep(ring r1, ring r2);
87void   rUnComplete(ring r);
88
89#define  rInternalChar(r) ((r)->ch)
90
91BOOLEAN rRing_is_Homog(ring r=currRing);
92BOOLEAN rRing_has_CompLastBlock(ring r=currRing);
93
94#ifdef HAVE_RING2TOM
95inline BOOLEAN rField_is_Ring_2toM(ring r=currRing)
96{ return (r->ringtype == 1); }
97#endif
98
99#ifdef HAVE_RINGMODN
100inline BOOLEAN rField_is_Ring_ModN(ring r=currRing)
101{ return (r->ringtype == 2); }
102
103inline BOOLEAN rField_is_Ring_PtoM(ring r=currRing)
104{ return (r->ringtype == 3); }
105#endif
106
107#ifdef HAVE_RINGZ
108inline BOOLEAN rField_is_Ring_Z(ring r=currRing)
109{ return (r->ringtype == 4); }
110#endif
111
112#ifdef HAVE_RINGS
113inline BOOLEAN rField_is_Ring(ring r=currRing)
114{ return (r->ringtype != 0); }
115
116inline BOOLEAN rField_is_Domain(ring r=currRing)
117{ return (r->ringtype == 4 || r->ringtype == 0); }
118
119inline BOOLEAN rField_has_Units(ring r=currRing)
120{ return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); }
121#else
122#define rField_is_Ring(A) (0)
123#endif
124
125#ifdef HAVE_RINGS
126inline BOOLEAN rField_is_Zp(ring r=currRing)
127{ return (r->ringtype == 0) && (r->ch > 1) && (r->parameter==NULL); }
128
129inline BOOLEAN rField_is_Zp(ring r, int p)
130{ return (r->ringtype == 0) && (r->ch > 1 && r->ch == ABS(p) && r->parameter==NULL); }
131
132inline BOOLEAN rField_is_Q(ring r=currRing)
133{ return (r->ringtype == 0) && (r->ch == 0) && (r->parameter==NULL); }
134
135inline BOOLEAN rField_is_numeric(ring r=currRing) /* R, long R, long C */
136{ return (r->ringtype == 0) && (r->ch ==  -1); }
137
138inline BOOLEAN rField_is_R(ring r=currRing)
139{
140  if (rField_is_numeric(r) && (r->float_len <= (short)SHORT_REAL_LENGTH))
141    return (r->ringtype == 0) && (r->parameter==NULL);
142  return FALSE;
143}
144
145inline BOOLEAN rField_is_GF(ring r=currRing)
146{ return (r->ringtype == 0) && (r->ch > 1) && (r->parameter!=NULL); }
147
148inline BOOLEAN rField_is_GF(ring r, int q)
149{ return (r->ringtype == 0) && (r->ch == q); }
150
151inline BOOLEAN rField_is_Zp_a(ring r=currRing)
152{ return (r->ringtype == 0) && (r->ch < -1); }
153
154inline BOOLEAN rField_is_Zp_a(ring r, int p)
155{ return (r->ringtype == 0) && (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
156
157inline BOOLEAN rField_is_Q_a(ring r=currRing)
158{ return (r->ringtype == 0) && (r->ch == 1); }
159
160inline BOOLEAN rField_is_long_R(ring r=currRing)
161{
162  if (rField_is_numeric(r) && (r->float_len >(short)SHORT_REAL_LENGTH))
163    return (r->ringtype == 0) && (r->parameter==NULL);
164  return FALSE;
165}
166
167inline BOOLEAN rField_is_long_C(ring r=currRing)
168{
169  if (rField_is_numeric(r))
170    return (r->ringtype == 0) && (r->parameter!=NULL);
171  return FALSE;
172}
173#else
174inline BOOLEAN rField_is_Zp(ring r=currRing)
175{ return (r->ch > 1) && (r->parameter==NULL); }
176
177inline BOOLEAN rField_is_Zp(ring r, int p)
178{ return (r->ch > 1 && r->ch == ABS(p) && r->parameter==NULL); }
179
180inline BOOLEAN rField_is_Q(ring r=currRing)
181{ return (r->ch == 0) && (r->parameter==NULL); }
182
183inline BOOLEAN rField_is_numeric(ring r=currRing) /* R, long R, long C */
184{ return (r->ch ==  -1); }
185
186inline BOOLEAN rField_is_R(ring r=currRing)
187{
188  if (rField_is_numeric(r) && (r->float_len <= (short)SHORT_REAL_LENGTH))
189    return (r->parameter==NULL);
190  return FALSE;
191}
192
193inline BOOLEAN rField_is_GF(ring r=currRing)
194{ return (r->ch > 1) && (r->parameter!=NULL); }
195
196inline BOOLEAN rField_is_GF(ring r, int q)
197{ return (r->ch == q); }
198
199inline BOOLEAN rField_is_Zp_a(ring r=currRing)
200{ return (r->ch < -1); }
201
202inline BOOLEAN rField_is_Zp_a(ring r, int p)
203{ return (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
204
205inline BOOLEAN rField_is_Q_a(ring r=currRing)
206{ return (r->ch == 1); }
207
208inline BOOLEAN rField_is_long_R(ring r=currRing)
209{
210  if (rField_is_numeric(r) && (r->float_len >(short)SHORT_REAL_LENGTH))
211    return (r->parameter==NULL);
212  return FALSE;
213}
214
215inline BOOLEAN rField_is_long_C(ring r=currRing)
216{
217  if (rField_is_numeric(r))
218    return (r->parameter!=NULL);
219  return FALSE;
220}
221#endif
222
223inline BOOLEAN rField_has_simple_inverse(ring r=currRing)
224/* { return (r->ch>1) || (r->ch== -1); } *//* Z/p, GF(p,n), R, long_R, long_C*/
225#ifdef HAVE_RINGS
226{ return (r->ringtype > 0) || (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/2^n, Z/p, GF(p,n), R, long_R, long_C*/
227#else
228{ return (r->ch>1) || ((r->ch== -1) && (r->float_len < 10)); } /* Z/p, GF(p,n), R, long_R, long_C*/
229#endif
230
231inline BOOLEAN rField_has_simple_Alloc(ring r=currRing)
232{ return (rField_is_Zp(r)
233       || rField_is_GF(r)
234#ifdef HAVE_RING2TOM
235       || rField_is_Ring_2toM(r)
236#endif
237       || rField_is_R(r)); }
238
239/* Z/p, GF(p,n), R: nCopy, nNew, nDelete are dummies*/
240inline BOOLEAN rField_is_Extension(ring r=currRing)
241{ return (rField_is_Q_a(r)) || (rField_is_Zp_a(r)); } /* Z/p(a) and Q(a)*/
242
243n_coeffType rFieldType(ring r);
244
245// this needs to be called whenever a new ring is created: new fields
246// in ring are created (like VarOffset), unless they already exist
247// with force == 1, new fields are _always_ created (overwritten),
248// even if they exist
249BOOLEAN rComplete(ring r, int force = 0);
250// use this to free fields created by rComplete
251
252inline int rBlocks(ring r)
253{
254  int i=0;
255  while (r->order[i]!=0) i++;
256  return i+1;
257}
258
259// misc things
260inline char* rRingVar(short i)
261{
262  return currRing->names[i];
263}
264inline char* rRingVar(short i, ring r)
265{
266  return r->names[i];
267}
268inline BOOLEAN rShortOut(ring r)
269{
270  return (r->ShortOut);
271}
272
273// order stuff
274typedef enum rRingOrder_t
275{
276  ringorder_no = 0,
277  ringorder_a,
278  ringorder_a64, // for int64 weights
279  ringorder_c,
280  ringorder_C,
281  ringorder_M,
282  ringorder_S,
283  ringorder_s,
284  ringorder_lp,
285  ringorder_dp,
286  ringorder_rp,
287  ringorder_Dp,
288  ringorder_wp,
289  ringorder_Wp,
290  ringorder_ls,
291  ringorder_ds,
292  ringorder_Ds,
293  ringorder_ws,
294  ringorder_Ws,
295  ringorder_L,
296  // the following are only used internally
297  ringorder_aa, // for idElimination, like a, except pFDeg, pWeigths ignore it
298  ringorder_rs,
299  ringorder_unspec
300} rRingOrder_t;
301
302typedef enum rOrderType_t
303{
304  rOrderType_General = 0, // non-simple ordering as specified by currRing
305  rOrderType_CompExp,     // simple ordering, component has priority
306  rOrderType_ExpComp,     // simple ordering, exponent vector has priority
307                          // component not compatible with exp-vector order
308  rOrderType_Exp,         // simple ordering, exponent vector has priority
309                          // component is compatible with exp-vector order
310  rOrderType_Syz,         // syzygy ordering
311  rOrderType_Schreyer,    // Schreyer ordering
312  rOrderType_Syz2dpc,     // syzcomp2dpc
313  rOrderType_ExpNoComp    // simple ordering, differences in component are
314                          // not considered
315} rOrderType_t;
316
317inline BOOLEAN rIsSyzIndexRing(ring r)
318{ return r->order[0] == ringorder_s;}
319
320inline int rGetCurrSyzLimit(ring r = currRing)
321{ return (r->order[0] == ringorder_s ?
322          r->typ[0].data.syz.limit : 0);}
323
324// Ring Manipulations
325ring   rAssure_HasComp(ring r);
326ring   rCurrRingAssure_SyzComp();
327void   rSetSyzComp(int k);
328ring   rCurrRingAssure_dp_S();
329ring   rCurrRingAssure_dp_C();
330ring   rCurrRingAssure_C_dp();
331// makes sure that c/C ordering is last ordering
332ring   rCurrRingAssure_CompLastBlock();
333// makes sure that c/C ordering is last ordering and SyzIndex is first
334ring   rCurrRingAssure_SyzComp_CompLastBlock();
335ring rAssure_TDeg(ring r, int start_var, int end_var, int &pos);
336
337// return the max-comonent wchich has syzIndex i
338// Assume: i<= syzIndex_limit
339int rGetMaxSyzComp(int i);
340
341BOOLEAN rHasSimpleOrder(const ring r);
342// returns TRUE, if simple lp or ls ordering
343BOOLEAN rHasSimpleLexOrder(const ring r);
344// return TRUE if p->exp[r->pOrdIndex] holds total degree of p */
345//inline BOOLEAN rHasGlobalOrdering(const ring r=currRing)
346//{ return (r->OrdSgn==1); }
347#define rHasGlobalOrdering(R) ((R)->OrdSgn==1)
348#define rHasGlobalOrdering_currRing() (pOrdSgn==1)
349//inline BOOLEAN rHasLocalOrMixedOrdering(const ring r=currRing)
350//{ return (r->OrdSgn==-1); }
351#define rHasLocalOrMixedOrdering(R) ((R)->OrdSgn==-1)
352#define rHasLocalOrMixedOrdering_currRing() (pOrdSgn==-1)
353BOOLEAN rOrd_is_Totaldegree_Ordering(ring r =currRing);
354// return TRUE if p_SetComp requires p_Setm
355BOOLEAN rOrd_SetCompRequiresSetm(ring r);
356rOrderType_t    rGetOrderType(ring r);
357/* returns TRUE if var(i) belongs to p-block */
358BOOLEAN rIsPolyVar(int i, ring r = currRing);
359
360inline BOOLEAN rOrd_is_Comp_dp(ring r)
361{
362  return ((r->order[0] == ringorder_c || r->order[0] == ringorder_C) &&
363          r->order[1] == ringorder_dp &&
364          r->order[2] == 0);
365}
366
367#ifdef RDEBUG
368#define rTest(r)    rDBTest(r, __FILE__, __LINE__)
369extern BOOLEAN rDBTest(ring r, const char* fn, const int l);
370#else
371#define rTest(r)
372#endif
373
374ring rModifyRing(ring r, BOOLEAN omit_degree,
375                         BOOLEAN omit_comp,
376                         unsigned long exp_limit);
377// construct Wp, C ring
378ring rModifyRing_Wp(ring r, int* weights);
379void rModify_a_to_A(ring r);
380
381void rKillModifiedRing(ring r);
382// also frees weights
383void rKillModified_Wp_Ring(ring r);
384
385ring rModifyRing_Simple(ring r, BOOLEAN omit_degree, BOOLEAN omit_comp, unsigned long exp_limit, BOOLEAN &simple);
386void rKillModifiedRing_Simple(ring r);
387
388void rDebugPrint(ring r);
389void pDebugPrint(poly p);
390void p_DebugPrint(poly p, const ring r);
391
392int64 * rGetWeightVec(ring r);
393void rSetWeightVec(ring r, int64 *wv);
394
395lists rDecompose(const ring r);
396ring rCompose(const lists  L);
397/////////////////////////////
398// Auxillary functions
399//
400
401BOOLEAN rCheckIV(intvec *iv);
402int rTypeOfMatrixOrder(intvec * order);
403void rDelete(ring r);
404
405#endif
Note: See TracBrowser for help on using the repository browser.