My Project
Loading...
Searching...
No Matches
pDebug.cc
Go to the documentation of this file.
1/****************************************
2* Computer Algebra System SINGULAR *
3****************************************/
4/***************************************************************
5 * File: pDebug.h
6 * Purpose: implementation of debug related poly routines
7 * Author: obachman (Olaf Bachmann)
8 * Created: 8/00
9 *******************************************************************/
10
11#ifndef PDEBUG_CC
12#define PDEBUG_CC
13
14#include <stdarg.h>
15#include <stdio.h>
16
17
18
19
20
21#include "misc/auxiliary.h"
22#include "misc/distrib.h"
23
24
25#ifdef PDEBUG
26
27// do the following to always enforce checking of pSetm
28// #undef PDEBUG
29// #define PDEBUG 2
30
33
34#include "coeffs/coeffs.h"
35
36/***************************************************************
37 *
38 * Error reporting
39 *
40 ***************************************************************/
41// avoid recursive calls
43BOOLEAN dPolyReportError(poly p, ring r, const char* fmt, ...)
44{
45 if (d_poly_error_reporting) return FALSE;
47 va_list ap;
48 va_start(ap, fmt);
49
50 fprintf(stderr, "\n// ***dPolyReportError: ");
51 vfprintf(stderr, fmt, ap);
52 fprintf(stderr, "\n occurred at\n");
53 #ifdef HAVE_OMALLOC
55 #endif
56 if (p != NULL)
57 {
58 fprintf(stderr, " occurred for poly: ");
59 p_wrp(p, r);
60 omPrintAddrInfo(stderr, p, " ");
61 }
62 #ifndef MAKE_DISTRIBUTION
64 #endif
66 return FALSE;
67}
68
69/***************************************************************
70 *
71 * checking for ring stuff
72 *
73 ***************************************************************/
75{
76 if (p != NULL)
77 {
78 #if (OM_TRACK > 0) && defined(OM_TRACK_CUSTOM)
79 void* custom = omGetCustomOfAddr(p);
80 if (custom != NULL)
81 {
82 pPolyAssumeReturnMsg(custom == r ||
83 // be more sloppy for qrings
84 (r->qideal != NULL &&
86 omSizeWOfAddr(p)==omSizeWOfBin(r->PolyBin)) ||
87 rSamePolyRep((ring) custom, r),
88 "monomial not from specified ring",p,r);
89 return TRUE;
90 }
91 else
92 #endif
93 #ifndef X_OMALLOC
94 {
97 return TRUE;
98 }
99 return FALSE;
100 #endif
101 }
102 return TRUE;
103}
104
106{
107 while (p!=NULL)
108 {
110 pIter(p);
111 }
112 return TRUE;
113}
114
116{
117 #ifndef X_OMALLOC
118 pAssumeReturn(r != NULL && r->PolyBin != NULL);
119 #endif
120 return p_CheckIsFromRing(p, r);
121}
122
124{
125 #ifndef X_OMALLOC
126 pAssumeReturn(r != NULL && r->PolyBin != NULL);
127 #endif
128 pAssumeReturn(p != NULL);
129 return p_LmCheckIsFromRing(p, r);
130}
132{
133 #ifndef X_OMALLOC
134 pAssumeReturn(r != NULL && r->PolyBin != NULL);
135 #endif
136 return TRUE;
137}
138
139/***************************************************************
140 *
141 * Debugging/statistics of pDivisibleBy
142 *
143 ***************************************************************/
145{
146 int i=r->N;
147
148 do
149 {
150 if (p_GetExp(a,i,r) > p_GetExp(b,i,r))
151 return FALSE;
152 i--;
153 }
154 while (i);
155 return n_DivBy(pGetCoeff(b), pGetCoeff(a), r->cf);
156}
157
158
159/***************************************************************
160 *
161 * Misc things helpful for debugging
162 *
163 ***************************************************************/
165{
166 if (m == NULL) return TRUE;
167 while (p != NULL)
168 {
169 if (p == m) return TRUE;
170 pIter(p);
171 }
172 return FALSE;
173}
175{
176 while (p != NULL)
177 {
178 if (pIsMonomOf(q, p))
179 {
180 return TRUE;
181 }
182 pIter(p);
183 }
184 return FALSE;
185}
186
187/***************************************************************
188 *
189 * Testing of polys
190 *
191 ***************************************************************/
192extern void p_Setm_General(poly p, ring r);
193
194static poly p_DebugInit(poly p, ring src_ring, ring dest_ring)
195{
196 poly d_p = p_Init(dest_ring);
197 int i;
198 assume(dest_ring->N == src_ring->N);
199
200 for (i=1; i<= src_ring->N; i++)
201 {
202 p_SetExp(d_p, i, p_GetExp(p, i, src_ring), dest_ring);
203 }
204 if (rRing_has_Comp(dest_ring))
205 p_SetComp(d_p, p_GetComp(p, src_ring), dest_ring);
206
207 p_Setm_General(d_p, dest_ring);
208 return d_p;
209}
210
211BOOLEAN _p_Test(poly p, ring r, int level)
212{
213 assume(r->cf !=NULL);
214
215 if (PDEBUG > level) level = PDEBUG;
216 if (level < 0 || p == NULL) return TRUE;
217
218 poly p_prev = NULL;
219
220 #ifndef OM_NDEBUG
221 #ifndef X_OMALLOC
222 // check addr with level+1 so as to check bin/page of addr
223 _pPolyAssumeReturnMsg(omTestBinAddrSize(p, (omSizeWOfBin(r->PolyBin))*SIZEOF_LONG, level+1)
224 == omError_NoError, "memory error",p,r);
225 #endif
226 #endif
227
229
230 // this checks that p does not contain a loop: rather expensive O(length^2)
231 #ifndef OM_NDEBUG
232 if (level > 1)
234 #endif
235
236 int ismod = p_GetComp(p, r) != 0;
237
238 while (p != NULL)
239 {
240 // ring check
242 #ifndef OM_NDEBUG
243 #ifndef X_OMALLOC
244 // omAddr check
245 _pPolyAssumeReturnMsg(omTestBinAddrSize(p, (omSizeWOfBin(r->PolyBin))*SIZEOF_LONG, 1)
246 == omError_NoError, "memory error",p,r);
247 #endif
248 #endif
249 // number/coef check
250 _pPolyAssumeReturnMsg(p->coef != NULL || (n_GetChar(r->cf) >= 2), "NULL coef",p,r);
251
252 #ifdef LDEBUG
253 _pPolyAssumeReturnMsg(n_Test(p->coef,r->cf),"coeff err",p,r);
254 #endif
255 _pPolyAssumeReturnMsg(!n_IsZero(p->coef, r->cf), "Zero coef",p,r);
256
257 // check for valid comp
258 _pPolyAssumeReturnMsg(p_GetComp(p, r) >= 0 && (p_GetComp(p, r)<65000), "component out of range ?",p,r);
259 // check for mix poly/vec representation
260 _pPolyAssumeReturnMsg(ismod == (p_GetComp(p, r) != 0), "mixed poly/vector",p,r);
261
262 // special check for ringorder_s/S
263 if ((r->typ!=NULL) && (r->typ[0].ord_typ == ro_syzcomp))
264 {
265 long c1, cc1, ccc1, ec1;
266 sro_ord* o = &(r->typ[0]);
267
268 c1 = p_GetComp(p, r);
269 if (o->data.syzcomp.Components!=NULL)
270 {
271 cc1 = o->data.syzcomp.Components[c1];
272 ccc1 = o->data.syzcomp.ShiftedComponents[cc1];
273 }
274 else { cc1=0; ccc1=0; }
275 _pPolyAssumeReturnMsg(c1 == 0 || cc1 != 0, "Component <-> TrueComponent zero mismatch",p,r);
276 _pPolyAssumeReturnMsg(c1 == 0 || ccc1 != 0,"Component <-> ShiftedComponent zero mismatch",p,r);
277 ec1 = p->exp[o->data.syzcomp.place];
278 //pPolyAssumeReturnMsg(ec1 == ccc1, "Shifted comp out of sync. should %d, is %d");
279 if (ec1 != ccc1)
280 {
281 dPolyReportError(p,r,"Shifted comp out of sync. should %d, is %d",ccc1,ec1);
282 return FALSE;
283 }
284 }
285
286 // check that p_Setm works ok
287 if (level > 0)
288 {
289 poly p_should_equal = p_DebugInit(p, r, r);
290 _pPolyAssumeReturnMsg(p_ExpVectorEqual(p, p_should_equal, r), "p_Setm field(s) out of sync",p,r);
291 p_LmFree(p_should_equal, r);
292 }
293
294 // check order
295 if (p_prev != NULL)
296 {
297 int cmp = p_LmCmp(p_prev, p, r);
298 if (cmp == 0)
299 {
300 _pPolyAssumeReturnMsg(0, "monoms p and p->next are equal", p_prev, r);
301 }
302 else
303 _pPolyAssumeReturnMsg(p_LmCmp(p_prev, p, r) == 1, "wrong order", p_prev, r);
304
305 // check that compare worked sensibly
306 if (level > 1 && p_GetComp(p_prev, r) == p_GetComp(p, r))
307 {
308 int i;
309 for (i=r->N; i>0; i--)
310 {
311 if (p_GetExp(p_prev, i, r) != p_GetExp(p, i, r)) break;
312 }
313 _pPolyAssumeReturnMsg(i > 0, "Exponents equal but compare different", p_prev, r);
314 }
315 }
316 p_prev = p;
317 pIter(p);
318 }
319 return TRUE;
320}
321
322BOOLEAN _p_LmTest(poly p, ring r, int level)
323{
324 if (level < 0 || p == NULL) return TRUE;
325 poly pnext = pNext(p);
326 pNext(p) = NULL;
327 BOOLEAN test_res = _p_Test(p, r, level);
328 pNext(p) = pnext;
329 return test_res;
330}
331
332BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
333{
334 if (PDEBUG > level) level = PDEBUG;
335 if (level < 0 || p == NULL) return TRUE;
336 if (pNext(p) == NULL || lmRing == tailRing) return _p_Test(p, lmRing, level);
337
338 pFalseReturn(_p_LmTest(p, lmRing, level));
339 pFalseReturn(_p_Test(pNext(p), tailRing, level));
340
341 // check that lm > Lm(tail)
342 if (level > 1)
343 {
344 poly lm = p;
345 poly tail = p_DebugInit(pNext(p), tailRing, lmRing);
346 poly pnext = pNext(lm);
347 pNext(lm) = tail;
348 BOOLEAN cmp = p_LmCmp(lm, tail, lmRing);
349 if (cmp != 1)
350 dPolyReportError(lm, lmRing, "wrong order: lm <= Lm(tail)");
351 p_LmFree(tail, lmRing);
352 pNext(lm) = pnext;
353 return (cmp == 1);
354 }
355 return TRUE;
356}
357
358#endif // PDEBUG
359
360#endif // PDEBUG_CC
All the auxiliary stuff.
int BOOLEAN
Definition auxiliary.h:88
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
#define PDEBUG
Definition auxiliary.h:171
int level(const CanonicalForm &f)
int m
Definition cfEzgcd.cc:128
int i
Definition cfEzgcd.cc:132
int p
Definition cfModGcd.cc:4086
CanonicalForm b
Definition cfModGcd.cc:4111
Coefficient rings, fields and other domains suitable for Singular polynomials.
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition coeffs.h:713
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:468
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition coeffs.h:448
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition coeffs.h:748
#define STATIC_VAR
Definition globaldefs.h:7
void dErrorBreak(void)
#define assume(x)
Definition mod2.h:389
#define pPolyAssumeReturnMsg(cond, msg)
Definition monomials.h:137
#define p_GetComp(p, r)
Definition monomials.h:64
#define pFalseReturn(cond)
Definition monomials.h:139
#define pIter(p)
Definition monomials.h:37
#define pNext(p)
Definition monomials.h:36
#define pAssumeReturn(cond)
Definition monomials.h:78
#define _pPolyAssumeReturnMsg(cond, msg, p, r)
Definition monomials.h:124
#define _pPolyAssumeReturn(cond, p, r)
Definition monomials.h:101
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
#define rRing_has_Comp(r)
Definition monomials.h:266
Definition ap.h:40
#define omSizeWOfBin(bin_ptr)
#define omIsBinPageAddr(addr)
Definition omBinPage.h:68
@ omError_NoError
Definition omError.h:18
#define NULL
Definition omList.c:12
#define omTestList(ptr, level)
Definition omList.h:81
static poly p_DebugInit(poly p, ring src_ring, ring dest_ring)
Definition pDebug.cc:194
BOOLEAN pIsMonomOf(poly p, poly m)
Definition pDebug.cc:164
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition pDebug.cc:123
BOOLEAN _p_Test(poly p, ring r, int level)
Definition pDebug.cc:211
BOOLEAN p_CheckIsFromRing(poly p, ring r)
Definition pDebug.cc:105
void p_Setm_General(poly p, ring r)
Definition p_polys.cc:158
BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
Definition pDebug.cc:144
STATIC_VAR BOOLEAN d_poly_error_reporting
Definition pDebug.cc:42
BOOLEAN _p_LmTest(poly p, ring r, int level)
Definition pDebug.cc:322
BOOLEAN dPolyReportError(poly p, ring r, const char *fmt,...)
Definition pDebug.cc:43
BOOLEAN p_CheckRing(ring r)
Definition pDebug.cc:131
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition pDebug.cc:74
BOOLEAN p_CheckPolyRing(poly p, ring r)
Definition pDebug.cc:115
BOOLEAN pHaveCommonMonoms(poly p, poly q)
Definition pDebug.cc:174
BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
Definition pDebug.cc:332
static BOOLEAN p_ExpVectorEqual(poly p1, poly p2, const ring r1, const ring r2)
Definition p_polys.cc:4635
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition p_polys.h:490
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:249
static int p_LmCmp(poly p, poly q, const ring r)
Definition p_polys.h:1596
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition p_polys.h:471
static void p_LmFree(poly p, ring)
Definition p_polys.h:685
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1336
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition polys0.cc:373
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
Definition ring.cc:1804
@ ro_syzcomp
Definition ring.h:60
union sro_ord::@006200034235045362245112336324125006204215012002 data
#define omTestBinAddrSize(A, B, C)
Definition xalloc.h:272
#define omPrintAddrInfo(A, B, C)
Definition xalloc.h:270
#define omPrintCurrentBackTraceMax(A, B)
Definition xalloc.h:265
#define omSizeWOfAddr(P)
Definition xalloc.h:223