source: git/kernel/ring.h @ d312f6

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