# source:git/libpolys/polys/monomials/monomials.h

spielwiese
Last change on this file was ed6db89, checked in by Hans Schoenemann <hannes@…>, 16 months ago
Revert "omFreeBinAddr -> omFreeBin at some places": bin may be not PolyBin This reverts commit f29c0dff40e04fa25b05af058273cd20e40d5d2e.
• Property mode set to `100644`
File size: 9.6 KB
Line
1#ifndef MONOMIALS_H
2#define MONOMIALS_H
3/****************************************
4*  Computer Algebra System SINGULAR     *
5****************************************/
6/*
7* ABSTRACT
8*/
9
10#include "reporter/reporter.h" // for assume etc.
11#include "coeffs/coeffs.h" // ring,number
12
13/***************************************************************
14 *
15 * definition of the poly structure and its fields
16 *
17 ***************************************************************/
18
19struct spolyrec;
20typedef struct spolyrec *          poly;
21
22struct  spolyrec
23{
24  poly      next;           // next needs to be the first field
25  number    coef;           // and coef the second --- do not change this !!!
26  unsigned long exp[1];     // make sure that exp is aligned
27};
28
29/***************************************************************
30 *
31 * Primitives for accessing and setting fields of a poly
32 * poly must be != NULL
33 *
34 ***************************************************************/
35// next
36#define pNext(p)            ((p)->next)
37#define pIter(p)            (void)((p) = (p)->next)
38
39// coeff
40// #define pGetCoeff(p)        ((p)->coef)
41/// return an alias to the leading coefficient of p
42/// assumes that p != NULL
43/// NOTE: not copy
44static inline number& pGetCoeff(poly p)
45{
46  assume(p != NULL);
47  return p->coef;
48}
49
50#define p_GetCoeff(p,r)     pGetCoeff(p)
51//static inline number& p_GetCoeff(poly p, const ring r)
52//{
53//  assume(r != NULL);
54//  return pGetCoeff(p);
55//}
56
57
58//
59#define pSetCoeff0(p,n)     (p)->coef=(n)
60#define p_SetCoeff0(p,n,r)  pSetCoeff0(p,n)
61
62
63#define __p_GetComp(p, r)   (p)->exp[r->pCompIndex]
64#define p_GetComp(p, r)    ((long) (r->pCompIndex >= 0 ? __p_GetComp(p, r) : 0))
65
66
67/***************************************************************
68 *
69 * prepare debugging
70 *
71 ***************************************************************/
72
73#if defined(PDEBUG)
74
75extern BOOLEAN dPolyReportError(poly p, ring r, const char* fmt, ...);
76
77// macros for checking of polys
78#define pAssumeReturn(cond)                                  \
79do                                                          \
80{                                                           \
81  if (! (cond))                                             \
82  {                                                         \
83    dPolyReportError(NULL, NULL, "pAssume violation of: %s", \
84                 #cond);                                    \
85    return FALSE;                                           \
86  }                                                         \
87}                                                           \
88while (0)
89
90#define pAssume(cond)                                        \
91do                                                          \
92{                                                           \
93  if (! (cond))                                             \
94  {                                                         \
95    dPolyReportError(NULL, NULL, "pAssume violation of: %s", \
96                 #cond);                                    \
97  }                                                         \
98}                                                           \
99while (0)
100
101#define _pPolyAssumeReturn(cond, p, r)                       \
102do                                                          \
103{                                                           \
104  if (! (cond))                                             \
105  {                                                         \
106    dPolyReportError(p, r, "pPolyAssume violation of: %s",   \
107                 #cond);                                    \
108    return FALSE;                                           \
109  }                                                         \
110}                                                           \
111while (0)
112
113#define _pPolyAssume(cond,p,r)                                   \
114do                                                              \
115{                                                               \
116  if (! (cond))                                                 \
117  {                                                             \
118    dPolyReportError(p, r, "pPolyAssume violation of: %s",    \
119                 #cond);                                        \
120  }                                                             \
121}                                                               \
122while (0)
123
124#define _pPolyAssumeReturnMsg(cond, msg, p, r)   \
125do                                              \
126{                                               \
127  if (! (cond))                                 \
128  {                                             \
129    dPolyReportError(p, r, "%s ",  msg);        \
130    return FALSE;                               \
131  }                                             \
132}                                               \
133while (0)
134
135#define pPolyAssume(cond)        _pPolyAssume(cond, p, r)
136#define pPolyAssumeReturn(cond)  _pPolyAssumeReturn(cond, p, r)
137#define pPolyAssumeReturnMsg(cond, msg)  _pPolyAssumeReturnMsg(cond, msg, p, r)
138
139#define pFalseReturn(cond)  do {if (! (cond)) return FALSE;} while (0)
140#if (OM_TRACK > 2) && defined(OM_TRACK_CUSTOM)
142//void p_SetRingOfLeftv(leftv l, ring r);
143#else
144#define p_SetRingOfLm(p, r) do {} while (0)
145//#define p_SetRingOfLeftv(l, r) do {} while (0)
146#endif
147
148#else // ! defined(PDEBUG)
149#define pFalseReturn(cond)           do {} while (0)
150#define pAssume(cond)                do {} while (0)
151#define pPolyAssume(cond)            do {} while (0)
152#define _pPolyAssume(cond, p,r)      do {} while (0)
153#define pAssumeReturn(cond)          do {} while (0)
154#define pPolyAssumeReturn(cond)      do {} while (0)
155#define _pPolyAssumeReturn(cond,p,r) do {} while (0)
156#define p_SetRingOfLm(p, r)          do {} while (0)
157//#define p_SetRingOfLeftv(l, r)       do {} while (0)
158#endif // defined(PDEBUG)
159
160#if PDEBUG >= 1
161#define pAssume1             pAssume
162#define pPolyAssume1         pPolyAssume
163#define _pPolyAssume1        _pPolyAssume
164#define pAssumeReturn1       pAssumeReturn
165#define pPolyAssumeReturn1   pPolyAssumeReturn
166#define _pPolyAssumeReturn1  _pPolyAssumeReturn
167#define p_LmCheckPolyRing1    p_LmCheckPolyRing
168#define p_CheckRing1        p_CheckRing
169#define pIfThen1          pIfThen
170#else
171#define pAssume1(cond)               do {} while (0)
172#define pPolyAssume1(cond)           do {} while (0)
173#define _pPolyAssume1(cond,p,r)      do {} while (0)
174#define pAssumeReturn1(cond)         do {} while (0)
175#define pPolyAssumeReturn1(cond)     do {} while (0)
176#define _pPolyAssumeReturn1(cond,p,r)do {} while (0)
177#define p_LmCheckPolyRing1(p,r)       do {} while (0)
178#define p_CheckRing1(r)             do {} while (0)
179#define pIfThen1(cond, check)     do {} while (0)
180#endif // PDEBUG >= 1
181
182#if PDEBUG >= 2
183#define pAssume2             pAssume
184#define pPolyAssume2         pPolyAssume
185#define _pPolyAssume2        _pPolyAssume
186#define pAssumeReturn2       pAssumeReturn
187#define pPolyAssumeReturn2   pPolyAssumeReturn
188#define _pPolyAssumeReturn2  _pPolyAssumeReturn
189#define p_LmCheckPolyRing2    p_LmCheckPolyRing
190#define p_CheckRing2        p_CheckRing
191#define pIfThen2          pIfThen
192#else
193#define pAssume2(cond)               do {} while (0)
194#define pPolyAssume2(cond)           do {} while (0)
195#define _pPolyAssume2(cond,p,r)      do {} while (0)
196#define pAssumeReturn2(cond)         do {} while (0)
197#define pPolyAssumeReturn2(cond)     do {} while (0)
198#define _pPolyAssumeReturn2(cond,p,r)do {} while (0)
199#define p_LmCheckPolyRing2(p,r)       do {} while (0)
200#define p_CheckRing2(r)             do {} while (0)
201#define pIfThen2(cond, check)     do {} while (0)
202#endif // PDEBUG >= 2
203
204/***************************************************************
205 *
206 * Macros for low-level allocation
207 *
208 ***************************************************************/
209#ifdef PDEBUG
210#define p_AllocBin(p, bin, r)                   \
211do                                              \
212{                                               \
213  omTypeAllocBin(poly, p, bin);                 \
214  p_SetRingOfLm(p, r);                        \
215}                                               \
216while (0)
218#else
219#define p_AllocBin(p, bin, r)   omTypeAllocBin(poly, p, bin)
221#endif
222
223/***************************************************************
224 *
225 * Purpose:    low-level and macro definition of polys
226 *
227 * If you touch anything here, you better know what you are doing.
228 * What is here should not be used directly from other routines -- the
229 * encapsulations in polys.h should be used, instead.
230 *
231 ***************************************************************/
232
233#define POLYSIZE (sizeof(poly) + sizeof(number))
234#define POLYSIZEW (POLYSIZE / sizeof(long))
235#if SIZEOF_LONG == 8
236#define POLY_NEGWEIGHT_OFFSET (((long)0x80000000) << 32)
237#else
238#define POLY_NEGWEIGHT_OFFSET ((long)0x80000000)
239#endif
240
241
242/***************************************************************
243 *
244 * Macros for low-level allocation
245 *
246 ***************************************************************/
247#ifdef PDEBUG
248#define p_AllocBin(p, bin, r)                   \
249do                                              \
250{                                               \
251  omTypeAllocBin(poly, p, bin);                 \
252  p_SetRingOfLm(p, r);                        \
253}                                               \
254while (0)
256#else
257#define p_AllocBin(p, bin, r)   omTypeAllocBin(poly, p, bin)