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 
19 struct spolyrec;
20 typedef struct spolyrec *          poly;
21 
22 struct  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
pGetCoeff(poly p)44 static 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 
75 extern BOOLEAN dPolyReportError(poly p, ring r, const char* fmt, ...);
76 
77 // macros for checking of polys
78 #define pAssumeReturn(cond)                                  \
79 do                                                          \
80 {                                                           \
81   if (! (cond))                                             \
82   {                                                         \
83     dPolyReportError(NULL, NULL, "pAssume violation of: %s", \
84                  #cond);                                    \
85     return FALSE;                                           \
86   }                                                         \
87 }                                                           \
88 while (0)
89 
90 #define pAssume(cond)                                        \
91 do                                                          \
92 {                                                           \
93   if (! (cond))                                             \
94   {                                                         \
95     dPolyReportError(NULL, NULL, "pAssume violation of: %s", \
96                  #cond);                                    \
97   }                                                         \
98 }                                                           \
99 while (0)
100 
101 #define _pPolyAssumeReturn(cond, p, r)                       \
102 do                                                          \
103 {                                                           \
104   if (! (cond))                                             \
105   {                                                         \
106     dPolyReportError(p, r, "pPolyAssume violation of: %s",   \
107                  #cond);                                    \
108     return FALSE;                                           \
109   }                                                         \
110 }                                                           \
111 while (0)
112 
113 #define _pPolyAssume(cond,p,r)                                   \
114 do                                                              \
115 {                                                               \
116   if (! (cond))                                                 \
117   {                                                             \
118     dPolyReportError(p, r, "pPolyAssume violation of: %s",    \
119                  #cond);                                        \
120   }                                                             \
121 }                                                               \
122 while (0)
123 
124 #define _pPolyAssumeReturnMsg(cond, msg, p, r)   \
125 do                                              \
126 {                                               \
127   if (! (cond))                                 \
128   {                                             \
129     dPolyReportError(p, r, "%s ",  msg);        \
130     return FALSE;                               \
131   }                                             \
132 }                                               \
133 while (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)
141 #define p_SetRingOfLm(p, r) omSetCustomOfAddr(p, r)
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)                   \
211 do                                              \
212 {                                               \
213   omTypeAllocBin(poly, p, bin);                 \
214   p_SetRingOfLm(p, r);                        \
215 }                                               \
216 while (0)
217 #define p_FreeBinAddr(p, r) p_LmFree(p, r)
218 #else
219 #define p_AllocBin(p, bin, r)   omTypeAllocBin(poly, p, bin)
220 #define p_FreeBinAddr(p, r)     omFreeBinAddr(p)
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)                   \
249 do                                              \
250 {                                               \
251   omTypeAllocBin(poly, p, bin);                 \
252   p_SetRingOfLm(p, r);                        \
253 }                                               \
254 while (0)
255 #define p_FreeBinAddr(p, r) p_LmFree(p, r)
256 #else
257 #define p_AllocBin(p, bin, r)   omTypeAllocBin(poly, p, bin)
258 #define p_FreeBinAddr(p, r)     omFreeBinAddr(p)
259 #endif
260 
261 /***************************************************************
262  *
263  * Misc macros
264  *
265  ***************************************************************/
266 #define rRing_has_Comp(r)   (r->pCompIndex >= 0)
267 
268 #endif
269