source: git/kernel/pInline1.h @ 32ed4f

spielwiese
Last change on this file since 32ed4f was 32ed4f, checked in by Oliver Wienand <wienand@…>, 18 years ago
kstd2.cc: deactivate zero reduction kutil.cc: chain crit restricted, need to be unleashed again p_Mult_nn__T.cc: Error in multiplication routine fixed pInline1.h: comments added git-svn-id: file:///usr/local/Singular/svn/trunk@9184 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 18.0 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/***************************************************************
5 *  File:    pInline1.h
6 *  Purpose: implementation of poly procs which iter over ExpVector
7 *  Author:  obachman (Olaf Bachmann)
8 *  Created: 8/00
9 *  Version: $Id: pInline1.h,v 1.6 2006-06-07 18:44:24 wienand Exp $
10 *******************************************************************/
11#ifndef PINLINE1_H
12#define PINLINE1_H
13
14#ifndef PDIV_DEBUG
15// define to enable debugging/statistics of pLmShortDivisibleBy
16// #define PDIV_DEBUG
17#endif
18#include <mylimits.h>
19#include "p_MemCmp.h"
20#include "structs.h"
21#include "numbers.h"
22
23#if PDEBUG > 0 || defined(NO_PINLINE1)
24
25#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS)  \
26do                                                          \
27{                                                           \
28  int _cmp = p_LmCmp(p,q,r);                                \
29  if (_cmp == 0) actionE;                                   \
30  if (_cmp == 1) actionG;                                   \
31  actionS;                                                  \
32}                                                           \
33while(0)
34
35#else
36
37#define _p_LmCmpAction(p, q, r, actionE, actionG, actionS)                      \
38 p_MemCmp_LengthGeneral_OrdGeneral(p->exp, q->exp, r->CmpL_Size, r->ordsgn,    \
39                                   actionE, actionG, actionS)
40
41#endif
42
43#ifdef PDIV_DEBUG
44BOOLEAN pDebugLmShortDivisibleBy(poly p1, unsigned long sev_1, ring r_1,
45                                 poly p2, unsigned long not_sev_2, ring r_2);
46BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r);
47#define pDivAssume  pAssume
48#else
49#define pDivAssume(x)   ((void)0)
50#endif
51
52#if !defined(NO_PINLINE1) || defined(PINLINE1_CC)
53
54#include "omalloc.h"
55#include "numbers.h"
56#include "p_polys.h"
57#include "p_MemAdd.h"
58#include "p_MemCopy.h"
59
60/***************************************************************
61 *
62 * Allocation/Initalization/Deletion
63 *
64 ***************************************************************/
65// adjustments for negative weights
66PINLINE1 void p_MemAdd_NegWeightAdjust(poly p, ring r)
67{
68  if (r->NegWeightL_Offset != NULL)
69  {
70    for (int i=r->NegWeightL_Size-1; i>=0; i--)
71    {
72      p->exp[r->NegWeightL_Offset[i]] -= POLY_NEGWEIGHT_OFFSET;
73    }
74  }
75}
76PINLINE1 void p_MemSub_NegWeightAdjust(poly p, ring r)
77{
78  if (r->NegWeightL_Offset != NULL)
79  {
80    for (int i=r->NegWeightL_Size-1; i>=0; i--)
81    {
82      p->exp[r->NegWeightL_Offset[i]] += POLY_NEGWEIGHT_OFFSET;
83    }
84  }
85}
86// ExpVextor(d_p) = ExpVector(s_p)
87PINLINE1 void p_ExpVectorCopy(poly d_p, poly s_p, ring r)
88{
89  p_LmCheckPolyRing1(d_p, r);
90  p_LmCheckPolyRing1(s_p, r);
91  p_MemCopy_LengthGeneral(d_p->exp, s_p->exp, r->ExpL_Size);
92}
93
94PINLINE1 poly p_Init(ring r, omBin bin)
95{
96  p_CheckRing1(r);
97  pAssume1(bin != NULL && r->PolyBin->sizeW == bin->sizeW);
98  poly p;
99  omTypeAlloc0Bin(poly, p, bin);
100  p_MemAdd_NegWeightAdjust(p, r);
101  p_SetRingOfLm(p, r);
102  return p;
103}
104PINLINE1 poly p_Init(ring r)
105{
106  return p_Init(r, r->PolyBin);
107}
108
109PINLINE1 poly p_LmInit(poly p, ring r)
110{
111  p_LmCheckPolyRing1(p, r);
112  poly np;
113  omTypeAllocBin(poly, np, r->PolyBin);
114  p_SetRingOfLm(np, r);
115  p_ExpVectorCopy(np, p, r);
116  _pNext(np) = NULL;
117  _pSetCoeff0(np, NULL);
118  return np;
119}
120PINLINE1 poly p_LmInit(poly s_p, ring s_r, ring d_r)
121{
122  pAssume1(d_r != NULL);
123  return p_LmInit(s_p, s_r, d_r, d_r->PolyBin);
124}
125PINLINE1 poly p_LmInit(poly s_p, ring s_r, ring d_r, omBin d_bin)
126{
127  p_LmCheckPolyRing1(s_p, s_r);
128  p_CheckRing(d_r);
129  pAssume1(d_r->N <= s_r->N);
130  poly d_p = p_Init(d_r, d_bin);
131  for (int i=d_r->N; i>0; i--)
132  {
133    p_SetExp(d_p, i, p_GetExp(s_p, i,s_r), d_r);
134  }
135  if (rRing_has_Comp(d_r))
136  {
137    p_SetComp(d_p, p_GetComp(s_p,s_r), d_r);
138  }
139  p_Setm(d_p, d_r);
140  return d_p;
141}
142PINLINE1 poly p_Head(poly p, ring r)
143{
144  if (p == NULL) return NULL;
145  p_LmCheckPolyRing1(p, r);
146  poly np;
147  omTypeAllocBin(poly, np, r->PolyBin);
148  p_SetRingOfLm(np, r);
149  p_ExpVectorCopy(np, p, r);
150  _pNext(np) = NULL;
151  _pSetCoeff0(np, n_Copy(_pGetCoeff(p), r));
152  return np;
153}
154
155PINLINE1 poly p_LmShallowCopyDelete(poly p, const ring r, omBin bin)
156{
157  p_LmCheckPolyRing1(p, r);
158  pAssume1(bin->sizeW == r->PolyBin->sizeW);
159  poly new_p = p_New(r);
160  p_MemCopy_LengthGeneral(new_p->exp, p->exp, r->ExpL_Size);
161  pSetCoeff0(new_p, pGetCoeff(p));
162  pNext(new_p) = pNext(p);
163  omFreeBinAddr(p);
164  return new_p;
165}
166
167/***************************************************************
168 *
169 * Operation on ExpVectors
170 *
171 ***************************************************************/
172// ExpVector(p1) += ExpVector(p2)
173PINLINE1 void p_ExpVectorAdd(poly p1, poly p2, ring r)
174{
175  p_LmCheckPolyRing1(p1, r);
176  p_LmCheckPolyRing1(p2, r);
177#if PDEBUG >= 1
178  for (int i=1; i<=r->N; i++)
179    pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
180  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
181#endif
182
183  p_MemAdd_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
184  p_MemAdd_NegWeightAdjust(p1, r);
185}
186// ExpVector(p1) -= ExpVector(p2)
187PINLINE1 void p_ExpVectorSub(poly p1, poly p2, ring r)
188{
189  p_LmCheckPolyRing1(p1, r);
190  p_LmCheckPolyRing1(p2, r);
191#if PDEBUG >= 1
192  for (int i=1; i<=r->N; i++)
193    pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
194  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0 ||
195          p_GetComp(p1, r) == p_GetComp(p2, r));
196#endif
197
198  p_MemSub_LengthGeneral(p1->exp, p2->exp, r->ExpL_Size);
199  p_MemSub_NegWeightAdjust(p1, r);
200
201}
202// ExpVector(p1) += ExpVector(p2) - ExpVector(p3)
203PINLINE1 void p_ExpVectorAddSub(poly p1, poly p2, poly p3, ring r)
204{
205  p_LmCheckPolyRing1(p1, r);
206  p_LmCheckPolyRing1(p2, r);
207  p_LmCheckPolyRing1(p3, r);
208#if PDEBUG >= 1
209  for (int i=1; i<=r->N; i++)
210    pAssume1(p_GetExp(p1, i, r) + p_GetExp(p2, i, r) >= p_GetExp(p3, i, r));
211  pAssume1(p_GetComp(p1, r) == 0 ||
212           (p_GetComp(p2, r) - p_GetComp(p3, r) == 0) ||
213           (p_GetComp(p1, r) == p_GetComp(p2, r) - p_GetComp(p3, r)));
214#endif
215
216  p_MemAddSub_LengthGeneral(p1->exp, p2->exp, p3->exp, r->ExpL_Size);
217  // no need to adjust in case of NegWeights
218}
219
220// ExpVector(pr) = ExpVector(p1) + ExpVector(p2)
221PINLINE1 void p_ExpVectorSum(poly pr, poly p1, poly p2, ring r)
222{
223  p_LmCheckPolyRing1(p1, r);
224  p_LmCheckPolyRing1(p2, r);
225  p_LmCheckPolyRing1(pr, r);
226#if PDEBUG >= 1
227  for (int i=1; i<=r->N; i++)
228    pAssume1((unsigned long) (p_GetExp(p1, i, r) + p_GetExp(p2, i, r)) <= r->bitmask);
229  pAssume1(p_GetComp(p1, r) == 0 || p_GetComp(p2, r) == 0);
230#endif
231
232  p_MemSum_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
233  p_MemAdd_NegWeightAdjust(pr, r);
234}
235// ExpVector(pr) = ExpVector(p1) - ExpVector(p2)
236PINLINE1 void p_ExpVectorDiff(poly pr, poly p1, poly p2, ring r)
237{
238  p_LmCheckPolyRing1(p1, r);
239  p_LmCheckPolyRing1(p2, r);
240  p_LmCheckPolyRing1(pr, r);
241#if PDEBUG >= 2
242  for (int i=1; i<=r->N; i++)
243    pAssume1(p_GetExp(p1, i, r) >= p_GetExp(p2, i, r));
244  pAssume1(!rRing_has_Comp(r) || p_GetComp(p1, r) == p_GetComp(p2, r));
245#endif
246
247  p_MemDiff_LengthGeneral(pr->exp, p1->exp, p2->exp, r->ExpL_Size);
248  p_MemSub_NegWeightAdjust(pr, r);
249}
250
251PINLINE1 BOOLEAN p_ExpVectorEqual(poly p1, poly p2, ring r)
252{
253  p_LmCheckPolyRing1(p1, r);
254  p_LmCheckPolyRing1(p2, r);
255
256  int i = r->ExpL_Size;
257  unsigned long *ep = p1->exp;
258  unsigned long *eq = p2->exp;
259
260  do
261  {
262    i--;
263    if (ep[i] != eq[i]) return FALSE;
264  }
265  while (i);
266  return TRUE;
267}
268
269PINLINE1 unsigned long p_ExpVectorQuerSum(poly p, ring r)
270{
271  p_LmCheckPolyRing1(p, r);
272  unsigned long s = p_GetTotalDegree(p->exp[r->VarL_Offset[0]],
273                                     r,
274                                     r->MinExpPerLong);
275  for (int i=r->VarL_Size-1; i>0; i--)
276  {
277    s += p_GetTotalDegree(p->exp[r->VarL_Offset[i]], r);
278  }
279  return s;
280}
281
282PINLINE1 void p_GetExpV(poly p, int *ev, ring r)
283{
284  p_LmCheckPolyRing1(p, r);
285  for (int j = r->N; j; j--)
286      ev[j] = p_GetExp(p, j, r);
287
288  ev[0] = _p_GetComp(p, r);
289}
290PINLINE1 void p_SetExpV(poly p, int *ev, ring r)
291{
292  p_LmCheckPolyRing1(p, r);
293  for (int j = r->N; j; j--)
294      p_SetExp(p, j, ev[j], r);
295
296  p_SetComp(p, ev[0],r);
297  p_Setm(p, r);
298}
299
300/***************************************************************
301 *
302 * Comparison w.r.t. monomial ordering
303 *
304 ***************************************************************/
305PINLINE1 int p_LmCmp(poly p, poly q, ring r)
306{
307  p_LmCheckPolyRing1(p, r);
308  p_LmCheckPolyRing1(q, r);
309
310  p_MemCmp_LengthGeneral_OrdGeneral(p->exp, q->exp, r->CmpL_Size, r->ordsgn,
311                                    return 0, return 1, return -1);
312}
313
314
315/***************************************************************
316 *
317 * divisibility
318 *
319 ***************************************************************/
320// return: FALSE, if there exists i, such that a->exp[i] > b->exp[i]
321//         TRUE, otherwise
322// (1) Consider long vars, instead of single exponents
323// (2) Clearly, if la > lb, then FALSE
324// (3) Suppose la <= lb, and consider first bits of single exponents in l:
325//     if TRUE, then value of these bits is la ^ lb
326//     if FALSE, then la-lb causes an "overflow" into one of those bits, i.e.,
327//               la ^ lb != la - lb
328static inline BOOLEAN _p_LmDivisibleByNoComp(poly a, poly b, ring r)
329{
330  int i=r->VarL_Size - 1;
331  unsigned long divmask = r->divmask;
332  unsigned long la, lb;
333
334  if (r->VarL_LowIndex >= 0)
335  {
336    i += r->VarL_LowIndex;
337    do
338    {
339      la = a->exp[i];
340      lb = b->exp[i];
341      if ((la > lb) ||
342          (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
343      {
344        pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == FALSE);
345        return FALSE;
346      }
347      i--;
348    }
349    while (i>=r->VarL_LowIndex);
350  }
351  else
352  {
353    do
354    {
355      la = a->exp[r->VarL_Offset[i]];
356      lb = b->exp[r->VarL_Offset[i]];
357      if ((la > lb) ||
358          (((la & divmask) ^ (lb & divmask)) != ((lb - la) & divmask)))
359      {
360        pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == FALSE);
361        return FALSE;
362      }
363      i--;
364    }
365    while (i>=0);
366  }
367  pDivAssume(p_DebugLmDivisibleByNoComp(a, b, r) == TRUE);
368#ifdef HAVE_RING2TOM
369  if (r->cring == 1) {
370    long lside = (long) p_GetCoeff(a, r);
371    long rside = (long) p_GetCoeff(b, r);
372    // Später durch bitvergleiche viel schneller TODO OLIVER
373    while (lside%2 == 0 && rside%2 == 0) {
374      lside = lside / 2;
375      rside = rside / 2;
376    }
377    return (lside%2 != 0);
378  }
379  else
380#endif
381  return TRUE;
382}
383
384#ifdef HAVE_RING2TOM
385/***************************************************************
386 *
387 * divisibility for rings (considers coefficients)
388 *
389 ***************************************************************/
390// return: FALSE, if there exists i, such that a->exp[i] > b->exp[i]
391//         TRUE, otherwise
392// (1) Consider long vars, instead of single exponents
393// (2) Clearly, if la > lb, then FALSE
394// (3) Suppose la <= lb, and consider first bits of single exponents in l:
395//     if TRUE, then value of these bits is la ^ lb
396//     if FALSE, then la-lb causes an "overflow" into one of those bits, i.e.,
397//               la ^ lb != la - lb
398static inline BOOLEAN _p_LmRingDivisibleByNoComp(poly a, poly b, ring r)
399{
400  BOOLEAN mDiv = _p_LmDivisibleByNoComp(a, b, r);
401  if (mDiv) {
402    long lside = (long) p_GetCoeff(a,r);
403    long rside = (long) p_GetCoeff(b,r);
404    // Später durch bitvergleiche viel schneller  TODO OLIVER
405    while (lside%2 == 0 && rside%2 == 0) {
406      lside = lside / 2;
407      rside = rside / 2;
408    }
409    return (lside%2 != 0);     // Is lside, i.e. LC(a), a unit?
410  }
411  return FALSE;
412}
413#endif
414
415static inline BOOLEAN _p_LmDivisibleByNoComp(poly a, ring r_a, poly b, ring r_b)
416{
417  int i=r_a->N;
418  pAssume1(r_a->N == r_b->N);
419
420  do
421  {
422    if (p_GetExp(a,i,r_a) > p_GetExp(b,i,r_b))
423      return FALSE;
424    i--;
425  }
426  while (i);
427#ifdef HAVE_RING2TOM
428  if (r_a->cring == 1 || r_b->cring == 1) {
429    long lside = (long) p_GetCoeff(a, r_a);
430    long rside = (long) p_GetCoeff(b, r_b);
431    // Später durch bitvergleiche viel schneller TODO OLIVER
432    while (lside%2 == 0 && rside%2 == 0) {
433      lside = lside / 2;
434      rside = rside / 2;
435    }
436    return (lside%2 != 0);
437  }
438  else
439#endif
440    return TRUE;
441}
442
443#ifdef HAVE_RING2TOM
444static inline BOOLEAN _p_LmRingDivisibleByNoComp(poly a, ring r_a, poly b, ring r_b)
445{
446  BOOLEAN mDiv = _p_LmDivisibleByNoComp(a, r_a, b, r_b);
447  if (mDiv) {
448    long lside = (long) p_GetCoeff(a, r_a);
449    long rside = (long) p_GetCoeff(b, r_b);
450    // Später durch bitvergleiche viel schneller TODO OLIVER
451    while (lside%2 == 0 && rside%2 == 0) {
452      lside = lside / 2;
453      rside = rside / 2;
454    }
455    return (lside%2 != 0);
456  }
457  return FALSE;
458}
459#endif
460
461static inline BOOLEAN _p_LmDivisibleBy(poly a, poly b, ring r)
462{
463  if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
464    return _p_LmDivisibleByNoComp(a, b, r);
465  return FALSE;
466}
467static inline BOOLEAN _p_LmDivisibleBy(poly a, ring r_a, poly b, ring r_b)
468{
469  if (p_GetComp(a, r_a) == 0 || p_GetComp(a,r_a) == p_GetComp(b,r_b))
470    return _p_LmDivisibleByNoComp(a, r_a, b, r_b);
471  return FALSE;
472}
473PINLINE1 BOOLEAN p_LmDivisibleByNoComp(poly a, poly b, ring r)
474{
475  p_LmCheckPolyRing1(a, r);
476  p_LmCheckPolyRing1(b, r);
477  return _p_LmDivisibleByNoComp(a, b, r);
478}
479PINLINE1 BOOLEAN p_LmDivisibleBy(poly a, poly b, ring r)
480{
481  p_LmCheckPolyRing1(b, r);
482  pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
483  if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
484    return _p_LmDivisibleByNoComp(a, b, r);
485  return FALSE;
486}
487
488#ifdef HAVE_RING2TOM
489PINLINE1 BOOLEAN p_LmRingDivisibleBy(poly a, poly b, ring r)
490{
491  p_LmCheckPolyRing1(b, r);
492  pIfThen1(a != NULL, p_LmCheckPolyRing1(b, r));
493  if (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r))
494    return _p_LmRingDivisibleByNoComp(a, b, r);
495  return FALSE;
496}
497#endif
498
499PINLINE1 BOOLEAN p_DivisibleBy(poly a, poly b, ring r)
500{
501  pIfThen1(b!=NULL, p_LmCheckPolyRing1(b, r));
502  pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r));
503
504  if (a != NULL && (p_GetComp(a, r) == 0 || p_GetComp(a,r) == p_GetComp(b,r)))
505#ifdef HAVE_RING2TOM
506    if (r->cring == 1) {
507      return _p_LmRingDivisibleByNoComp(a,b,r);
508    }
509    else
510#endif
511      return _p_LmDivisibleByNoComp(a,b,r);
512  return FALSE;
513}
514PINLINE1 BOOLEAN p_DivisibleBy(poly a, ring r_a, poly b, ring r_b)
515{
516  pIfThen1(b!=NULL, p_LmCheckPolyRing1(b, r_b));
517  pIfThen1(a!=NULL, p_LmCheckPolyRing1(a, r_a));
518  if (a != NULL) {
519#ifdef HAVE_RING2TOM
520    if (r_a->cring == 1) {
521      return _p_LmRingDivisibleByNoComp(a, r_a, b, r_b);
522    }
523    else
524#endif
525      return _p_LmDivisibleBy(a, r_a, b, r_b);
526  }
527  return FALSE;
528}
529PINLINE1 BOOLEAN p_LmDivisibleBy(poly a, ring r_a, poly b, ring r_b)
530{
531  p_LmCheckPolyRing(a, r_a);
532  p_LmCheckPolyRing(b, r_b);
533  return _p_LmDivisibleBy(a, r_a, b, r_b);
534}
535PINLINE1 BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a,
536                                    poly b, unsigned long not_sev_b, ring r)
537{
538  p_LmCheckPolyRing1(a, r);
539  p_LmCheckPolyRing1(b, r);
540#ifndef PDIV_DEBUG
541  _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
542  _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
543
544  if (sev_a & not_sev_b)
545  {
546    pAssume1(p_LmDivisibleByNoComp(a, b, r) == FALSE);
547    return FALSE;
548  }
549  return p_LmDivisibleBy(a, b, r);
550#else
551  return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
552#endif
553}
554
555#ifdef HAVE_RING2TOM
556PINLINE1 BOOLEAN p_LmRingShortDivisibleBy(poly a, unsigned long sev_a,
557                                          poly b, unsigned long not_sev_b, ring r)
558{
559  p_LmCheckPolyRing1(a, r);
560  p_LmCheckPolyRing1(b, r);
561#ifndef PDIV_DEBUG
562  _pPolyAssume2(p_GetShortExpVector(a, r) == sev_a, a, r);
563  _pPolyAssume2(p_GetShortExpVector(b, r) == ~ not_sev_b, b, r);
564
565  if (sev_a & not_sev_b)
566  {
567    pAssume1(_p_LmRingDivisibleByNoComp(a, b, r) == FALSE);
568    return FALSE;
569  }
570  return p_LmRingDivisibleBy(a, b, r);
571#else
572  return pDebugLmShortDivisibleBy(a, sev_a, r, b, not_sev_b, r);
573#endif
574}
575#endif
576
577PINLINE1 BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, ring r_a,
578                                      poly b, unsigned long not_sev_b, ring r_b)
579{
580  p_LmCheckPolyRing1(a, r_a);
581  p_LmCheckPolyRing1(b, r_b);
582#ifndef PDIV_DEBUG
583  _pPolyAssume2(p_GetShortExpVector(a, r_a) == sev_a, a, r_a);
584  _pPolyAssume2(p_GetShortExpVector(b, r_b) == ~ not_sev_b, b, r_b);
585
586  if (sev_a & not_sev_b)
587  {
588    pAssume1(_p_LmDivisibleByNoComp(a, r_a, b, r_b) == FALSE);
589    return FALSE;
590  }
591  return _p_LmDivisibleBy(a, r_a, b, r_b);
592#else
593  return pDebugLmShortDivisibleBy(a, sev_a, r_a, b, not_sev_b, r_b);
594#endif
595}
596
597/***************************************************************
598 *
599 * Misc things on Lm
600 *
601 ***************************************************************/
602// test if the monomial is a constant as a vector component
603// i.e., test if all exponents are zero
604PINLINE1 BOOLEAN p_LmIsConstantComp(const poly p, const ring r)
605{
606  //p_LmCheckPolyRing(p, r);
607  int i = r->VarL_Size - 1;
608
609  do
610  {
611    if (p->exp[r->VarL_Offset[i]] != 0)
612      return FALSE;
613    i--;
614  }
615  while (i >= 0);
616  return TRUE;
617}
618// test if monomial is a constant, i.e. if all exponents and the component
619// is zero
620PINLINE1 BOOLEAN p_LmIsConstant(const poly p, const ring r)
621{
622  if (p_LmIsConstantComp(p, r))
623    return (p_GetComp(p, r) == 0);
624  return FALSE;
625}
626
627// like the respective p_LmIs* routines, except that p might be empty
628PINLINE1 BOOLEAN p_IsConstantComp(const poly p, const ring r)
629{
630  if (p == NULL) return TRUE;
631  return (pNext(p)==NULL) && p_LmIsConstantComp(p, r);
632}
633
634PINLINE1 BOOLEAN p_IsConstant(const poly p, const ring r)
635{
636  if (p == NULL) return TRUE;
637  return (pNext(p)==NULL) && p_LmIsConstant(p, r);
638}
639
640PINLINE1 BOOLEAN p_IsUnit(const poly p, const ring r)
641{
642  if (p == NULL) return FALSE;
643  return p_LmIsConstant(p, r);
644}
645
646PINLINE1 BOOLEAN p_LmExpVectorAddIsOk(const poly p1, const poly p2,
647                                      const ring r)
648{
649  p_LmCheckPolyRing(p1, r);
650  p_LmCheckPolyRing(p2, r);
651  unsigned long l1, l2, divmask = r->divmask;
652  int i;
653
654  for (i=0; i<r->VarL_Size; i++)
655  {
656    l1 = p1->exp[r->VarL_Offset[i]];
657    l2 = p2->exp[r->VarL_Offset[i]];
658    // do the divisiblity trick
659    if ( (l1 > ULONG_MAX - l2) ||
660         (((l1 & divmask) ^ (l2 & divmask)) != ((l1 + l2) & divmask)))
661      return FALSE;
662  }
663  return TRUE;
664}
665
666#endif // !defined(NO_PINLINE1) || defined(PINLINE1_CC)
667#endif // PINLINE1_CC
Note: See TracBrowser for help on using the repository browser.