source: git/Singular/pInline2.h @ cb66fa

spielwiese
Last change on this file since cb66fa was cb66fa, checked in by Olaf Bachmann <obachman@…>, 24 years ago
* new implementation of PDEBUG stuff git-svn-id: file:///usr/local/Singular/svn/trunk@4595 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 8.8 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/***************************************************************
5 *  File:    pInline2.h
6 *  Purpose: implementation of poly procs which are of constant time
7 *  Author:  obachman (Olaf Bachmann)
8 *  Created: 8/00
9 *  Version: $Id: pInline2.h,v 1.3 2000-09-14 13:04:39 obachman Exp $
10 *******************************************************************/
11#ifndef PINLINE2_H
12#define PINLINE2_H
13
14/***************************************************************
15 *
16 * Primitives for accessing and setting fields of a poly
17 *
18 ***************************************************************/
19#if !defined(NO_PINLINE2) || defined(PINLINE2_CC)
20
21#include "mod2.h"
22#include "omalloc.h"
23#include "structs.h"
24#include "polys.h"
25#include "numbers.h"
26#include "p_Procs.h"
27
28
29PINLINE2 number p_SetCoeff(poly p, number n, ring r)
30{
31  p_CheckPolyRing2(p, r);
32  p_nDelete(&(p->coef), r);
33  (p)->coef=n;
34  return n;
35}
36
37// order
38PINLINE2 Order_t p_GetOrder(poly p, ring r)
39{
40  p_CheckPolyRing2(p, r);
41  return ((p)->exp[r->pOrdIndex]);
42}
43
44PINLINE2 Order_t p_SetOrder(poly p, long o, ring r)
45{
46  p_CheckPolyRing2(p, r);
47  pAssume2(o >= 0);
48  return (p)->exp[r->pOrdIndex] = o;
49}
50
51// component
52PINLINE2  unsigned long p_SetComp(poly p, unsigned long c, ring r)
53{
54  p_CheckPolyRing2(p, r);
55  pAssume2(rRing_has_Comp(r));
56  __p_GetComp(p,r) = c;
57  return c;
58}
59PINLINE2 unsigned long p_IncrComp(poly p, ring r)
60{
61  p_CheckPolyRing2(p, r);
62  pAssume2(rRing_has_Comp(r));
63  return ++(__p_GetComp(p,r));
64}
65PINLINE2 unsigned long p_DecrComp(poly p, ring r)
66{
67  p_CheckPolyRing2(p, r);
68  pAssume2(rRing_has_Comp(r));
69  pPolyAssume2(__p_GetComp(p,r) > 0);
70  return --(__p_GetComp(p,r));
71}
72PINLINE2 unsigned long p_AddComp(poly p, unsigned long v, ring r)
73{
74  p_CheckPolyRing2(p, r);
75  pAssume2(rRing_has_Comp(r));
76  return __p_GetComp(p,r) += v;
77}
78PINLINE2 unsigned long p_SubComp(poly p, unsigned long v, ring r)
79{
80  p_CheckPolyRing2(p, r);
81  pAssume2(rRing_has_Comp(r));
82  pPolyAssume2(__p_GetComp(p,r) >= v);
83  return __p_GetComp(p,r) -= v;
84}
85
86// exponent
87// r->VarOffset encodes the position in p->exp (lower 24 bits)
88// and number of bits to shift to the right in the upper 8 bits
89PINLINE2 Exponent_t p_GetExp(poly p, int v, ring r)
90{
91  p_CheckPolyRing2(p, r);
92  pAssume2(v > 0 && v <= r->N);
93  return (p->exp[(r->VarOffset[v] & 0xffffff)] >> (r->VarOffset[v] >> 24))
94          & r->bitmask;
95}
96PINLINE2 Exponent_t p_SetExp(poly p, int v, int e, ring r)
97{
98  p_CheckPolyRing2(p, r);
99  pAssume2(v>0 && v <= r->N);
100  pAssume2(e>=0);
101  pAssume2((unsigned int) e<=r->bitmask);
102
103  // shift e to the left:
104  register int shift = r->VarOffset[v] >> 24;
105  unsigned long ee = ((unsigned long)e) << shift /*(r->VarOffset[v] >> 24)*/;
106  // clear the bits in the exponent vector:
107  register int offset = (r->VarOffset[v] & 0xffffff);
108  p->exp[offset]  &=
109    ~( r->bitmask << shift );
110  // insert e with |
111  p->exp[ offset ] |= ee;
112  return e;
113}
114
115// the following should be implemented more efficiently
116PINLINE2  Exponent_t p_IncrExp(poly p, int v, ring r)
117{
118  p_CheckPolyRing2(p, r);
119  Exponent_t e = p_GetExp(p,v,r);
120  e++;
121  return p_SetExp(p,v,e,r);
122}
123PINLINE2  Exponent_t p_DecrExp(poly p, int v, ring r)
124{
125  p_CheckPolyRing2(p, r);
126  Exponent_t e = p_GetExp(p,v,r);
127  pAssume2(e > 0);
128  e--;
129  return p_SetExp(p,v,e,r);
130}
131PINLINE2  Exponent_t p_AddExp(poly p, int v, Exponent_t ee, ring r)
132{
133  p_CheckPolyRing2(p, r);
134  Exponent_t e = p_GetExp(p,v,r);
135  e += ee;
136  return p_SetExp(p,v,e,r);
137}
138PINLINE2  Exponent_t p_SubExp(poly p, int v, Exponent_t ee, ring r)
139{
140  p_CheckPolyRing2(p, r);
141  Exponent_t e = p_GetExp(p,v,r);
142  pAssume2(e >= ee);
143  e -= ee;
144  return p_SetExp(p,v,e,r);
145}
146PINLINE2  Exponent_t p_MultExp(poly p, int v, Exponent_t ee, ring r)
147{
148  p_CheckPolyRing2(p, r);
149  Exponent_t e = p_GetExp(p,v,r);
150  e *= ee;
151  return p_SetExp(p,v,e,r);
152}
153
154PINLINE2 Exponent_t p_GetExpSum(poly p1, poly p2, int i, ring r)
155{
156  p_CheckPolyRing2(p1, r);
157  p_CheckPolyRing2(p2, r);
158  return p_GetExp(p1,i,r) + p_GetExp(p2,i,r);
159}
160PINLINE2 Exponent_t p_GetExpDiff(poly p1, poly p2, int i, ring r)
161{
162  return p_GetExp(p1,i,r) - p_GetExp(p2,i,r);
163}
164
165
166/***************************************************************
167 *
168 * Allocation/Initalization/Deletion
169 *
170 ***************************************************************/
171PINLINE2 poly p_New(ring r)
172{
173  p_CheckRing2(r);
174  poly p;
175  omTypeAllocBin(poly, p, r->PolyBin);
176  p_SetRingOfPoly(p, r);
177  return p;
178}
179
180PINLINE2 void p_Delete1(poly *p, ring r)
181{
182  pIfThen2(*p != NULL, p_CheckPolyRing2(*p, r));
183  poly h = *p;
184  if (h != NULL)
185  {
186    p_nDelete(&_pGetCoeff(h), r);
187    *p = _pNext(h);
188    omFreeBinAddr(h);
189  }
190
191}
192PINLINE2 void p_Free(poly p, ring r)
193{
194  p_CheckPolyRing2(p, r);
195  omFreeBinAddr(p);
196}
197PINLINE2 poly p_FreeAndNext(poly p, ring r)
198{
199  p_CheckPolyRing2(p, r);
200  poly pnext = _pNext(p);
201  omFreeBinAddr(p);
202  return pnext;
203}
204PINLINE2 void p_LmDelete(poly p, ring r)
205{
206  p_CheckPolyRing2(p, r);
207  p_nDelete(&_pGetCoeff(p), r);
208  omFreeBinAddr(p);
209}
210PINLINE2 poly p_LmDeleteAndNext(poly p, ring r)
211{
212  p_CheckPolyRing2(p, r);
213  poly pnext = _pNext(p);
214  p_nDelete(&_pGetCoeff(p), r);
215  omFreeBinAddr(p);
216  return pnext;
217}
218
219/***************************************************************
220 *
221 * Misc routines
222 *
223 ***************************************************************/
224PINLINE2 int p_Cmp(poly p1, poly p2, ring r)
225{
226  if (p2==NULL)
227    return 1;
228  if (p1==NULL)
229    return -1;
230  return p_LmCmp(p1,p2,r);
231}
232
233/***************************************************************
234 *
235 * Dispatcher to r->p_Procs, they do the tests/checks
236 *
237 ***************************************************************/
238// returns a copy of p
239PINLINE2 poly p_Copy(poly p, const ring r)
240{
241  return r->p_Procs->p_Copy(p, r);
242}
243
244// deletes *p, and sets *p to NULL
245PINLINE2 void p_Delete(poly *p, const ring r)
246{
247  r->p_Procs->p_Delete(p, r);
248}
249
250// returns p+q, destroys p and q
251PINLINE2 poly p_Add_q(poly p, poly q, const ring r)
252{
253  int shorter;
254  return r->p_Procs->p_Add_q(p, q, shorter, r);
255}
256
257PINLINE2 poly p_Add_q(poly p, poly q, int &lp, int lq, const ring r)
258{
259  int shorter;
260  poly res = r->p_Procs->p_Add_q(p, q, shorter, r);
261  lp = (lp + lq) - shorter;
262  return res;
263}
264
265// returns p*n, destroys p
266PINLINE2 poly p_Mult_nn(poly p, number n, const ring r)
267{
268  return r->p_Procs->p_Mult_nn(p, n, r);
269}
270
271// returns p*n, does not destroy p
272PINLINE2 poly pp_Mult_nn(poly p, number n, const ring r)
273{
274  return r->p_Procs->pp_Mult_nn(p, n, r);
275}
276
277// returns Copy(p)*m, does neither destroy p nor m
278PINLINE2 poly pp_Mult_mm(poly p, poly m, const ring r)
279{
280  return r->p_Procs->pp_Mult_mm(p, m, NULL, r);
281}
282
283// returns p*m, destroys p, const: m
284PINLINE2 poly p_Mult_mm(poly p, poly m, const ring r)
285{
286  return r->p_Procs->p_Mult_mm(p, m, r);
287}
288
289// return p - m*Copy(q), destroys p; const: p,m
290PINLINE2 poly p_Minus_mm_Mult_qq(poly p, poly m, poly q, const ring r)
291{
292  int shorter;
293  return r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
294}
295PINLINE2 poly p_Minus_mm_Mult_qq(poly p, poly m, poly q, int &lp, int lq,
296                                 poly spNoether, const ring r)
297{
298  int shorter;
299  poly res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, spNoether, r);
300  lp = (lp + lq) - shorter;
301  return res;
302}
303
304// returns -p, destroys p
305PINLINE2 poly p_Neg(poly p, const ring r)
306{
307  return r->p_Procs->p_Neg(p, r);
308}
309
310extern poly  _p_Mult_q(poly p, poly q, const int copy, const ring r);
311// returns p*q, destroys p and q
312PINLINE2 poly p_Mult_q(poly p, poly q, const ring r)
313{
314  if (p == NULL)
315  {
316    r->p_Procs->p_Delete(&q, r);
317    return NULL;
318  }
319  if (q == NULL)
320  {
321    r->p_Procs->p_Delete(&p, r);
322    return NULL;
323  }
324
325  if (pNext(p) == NULL)
326  {
327
328    q = r->p_Procs->p_Mult_mm(q, p, r);
329    r->p_Procs->p_Delete(&p, r);
330    return q;
331  }
332
333  if (pNext(q) == NULL)
334  {
335    p = r->p_Procs->p_Mult_mm(p, q, r);
336    r->p_Procs->p_Delete(&q, r);
337    return p;
338  }
339
340  return _p_Mult_q(p, q, 0, r);
341}
342
343// returns p*q, does neither destroy p nor q
344PINLINE2 poly pp_Mult_qq(poly p, poly q, const ring r)
345{
346  if (p == NULL || q == NULL) return NULL;
347
348  if (pNext(p) == NULL)
349    return r->p_Procs->pp_Mult_mm(q, p, NULL, r);
350
351  if (pNext(q) == NULL)
352    return r->p_Procs->pp_Mult_mm(p, q, NULL, r);
353
354  poly qq = q;
355  if (p == q)
356    qq = p_Copy(q, r);
357
358  poly res = _p_Mult_q(p, qq, 1, r);
359  if (qq != q)
360    p_Delete(&qq, r);
361  return res;
362}
363
364// returns p + m*q destroys p, const: q, m
365// this should be implemented more efficiently
366PINLINE2 poly p_Plus_mm_Mult_qq(poly p, poly m, poly q, const ring r)
367{
368  poly res;
369  int shorter;
370  number n_old = pGetCoeff(m);
371  number n_neg = p_nCopy(n_old, r);
372  n_neg = p_nNeg(n_neg, r);
373  pSetCoeff0(m, n_neg);
374
375  res = r->p_Procs->p_Minus_mm_Mult_qq(p, m, q, shorter, NULL, r);
376  pSetCoeff0(m, n_old);
377  p_nDelete(&n_neg, r);
378  return res;
379}
380
381
382#endif // !defined(NO_PINLINE2) || defined(POLYS_IMPL_CC)
383#endif // PINLINE2_H
384
Note: See TracBrowser for help on using the repository browser.