source: git/Singular/pDebug.cc @ beb237

fieker-DuValspielwiese
Last change on this file since beb237 was beb237, checked in by Olaf Bachmann <obachman@…>, 24 years ago
* strat->tailRing progress!!! git-svn-id: file:///usr/local/Singular/svn/trunk@4679 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 8.6 KB
Line 
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 *  Version: $Id: pDebug.cc,v 1.10 2000-10-26 16:31:36 obachman Exp $
10 *******************************************************************/
11
12#ifndef PDEBUG_CC
13#define PDEBUG_CC
14#include <stdarg.h>
15#include <stdio.h>
16
17#include "mod2.h"
18#ifdef PDEBUG
19
20#include "p_polys.h"
21#include "febase.h"
22#include "omalloc.h"
23#include "ring.h"
24#include "numbers.h"
25
26
27/***************************************************************
28 *
29 * Error reporting
30 *
31 ***************************************************************/
32BOOLEAN dPolyReportError(poly p, ring r, const char* fmt, ...)
33{
34  va_list ap;
35  va_start(ap, fmt);
36 
37  fprintf(stderr, "\n// ***dPolyError: ");
38  vfprintf(stderr, fmt, ap);
39  fprintf(stderr, "\n occured at\n");
40  omPrintCurrentBackTraceMax(stderr, 8);
41  if (p != NULL)
42  {
43    if (r == currRing)
44    {
45      fprintf(stderr, " occured for poly: ");
46      p_wrp(p, r);
47      omPrintAddrInfo(stderr, p, " ");
48    }
49    else
50    {
51      omPrintAddrInfo(stderr, p, " occured for poly: ");
52    }
53  }
54  dErrorBreak();
55  return FALSE;
56}
57
58/***************************************************************
59 *
60 * checking for ring stuff
61 *
62 ***************************************************************/
63BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
64{
65  if (p != NULL)
66  {
67    void* custom = omGetCustomOfAddr(p);
68    if (custom != NULL)
69    {
70      pPolyAssumeReturnMsg(custom == r || rEqual((ring) custom, r, FALSE), 
71                           "monomial not from specified ring");
72      return TRUE;
73    }
74    else
75    {
76      pPolyAssumeReturn(omIsBinPageAddr(p) && omSizeWOfAddr(p)==r->PolyBin->sizeW);
77      return TRUE;
78    }
79    return FALSE;
80  }
81  return TRUE;
82}
83
84BOOLEAN p_CheckIsFromRing(poly p, ring r)
85{
86  while (p!=NULL)
87  {
88    pFalseReturn(p_LmCheckIsFromRing(p, r));
89    pIter(p);
90  }
91  return TRUE;
92}
93
94BOOLEAN p_CheckPolyRing(poly p, ring r)
95{
96  pAssumeReturn(r != NULL && r->PolyBin != NULL);
97  return p_CheckIsFromRing(p, r);
98}
99
100BOOLEAN p_LmCheckPolyRing(poly p, ring r)
101{
102  pAssumeReturn(r != NULL && r->PolyBin != NULL);
103  pAssumeReturn(p != NULL);
104  return p_LmCheckIsFromRing(p, r);
105}
106BOOLEAN p_CheckRing(ring r)
107{
108  pAssumeReturn(r != NULL && r->PolyBin != NULL);
109  return TRUE;
110}
111
112/***************************************************************
113 *
114 * Debugging/statistics of pDivisibleBy
115 *
116 ***************************************************************/
117BOOLEAN p_DebugLmDivisibleByNoComp(poly a, poly b, ring r)
118{
119  int i=r->N;
120
121  do
122  {
123    if (p_GetExp(a,i,r) > p_GetExp(b,i,r))
124      return FALSE;
125    i--;
126  }
127  while (i);
128  return TRUE;
129}
130
131
132/***************************************************************
133 *
134 * Misc things helpful for debugging
135 *
136 ***************************************************************/
137BOOLEAN pIsMonomOf(poly p, poly m)
138{
139  if (m == NULL) return TRUE;
140  while (p != NULL)
141  {
142    if (p == m) return TRUE;
143    pIter(p);
144  }
145  return FALSE;
146}
147BOOLEAN pHaveCommonMonoms(poly p, poly q)
148{
149  while (p != NULL)
150  {
151    if (pIsMonomOf(q, p))
152    {
153      return TRUE;
154    }
155    pIter(p);
156  }
157  return FALSE;
158}
159
160/***************************************************************
161 *
162 * Testing of polys
163 *
164 ***************************************************************/
165static poly p_DebugInit(poly p, ring dest_ring, ring src_ring)
166{
167  poly d_p = p_Init(dest_ring);
168  int i;
169  assume(dest_ring->N == src_ring->N);
170 
171  for (i=1; i<= src_ring->N; i++)
172  {
173    p_SetExp(d_p, i, p_GetExp(p, i, src_ring), dest_ring);
174  }
175  if (rRing_has_Comp(dest_ring))
176    p_SetComp(d_p, p_GetComp(p, src_ring), dest_ring);
177  p_Setm(d_p, dest_ring);
178  return d_p;
179}
180
181BOOLEAN _p_Test(poly p, ring r, int level)
182{
183  if (level < 0 || p == NULL) return TRUE;
184 
185  poly p_prev = NULL;
186 
187  // check addr with level+1 so as to check bin/page of addr
188  if (level > 0)
189    pPolyAssumeReturnMsg(omTestBinAddrSize(p, (r->PolyBin->sizeW)*SIZEOF_LONG, level+1)
190                        == omError_NoError, "memory error");
191
192  pFalseReturn(p_CheckRing(r));
193
194  // this checks that p does not contain a loop: rather expensive O(length^2)
195  if (level > 1)
196    pFalseReturn(omTestList(p, level) == omError_NoError);
197 
198  int ismod = p_GetComp(p, r) > 0;
199 
200  while (p != NULL)
201  {
202    // ring check
203    pFalseReturn(p_LmCheckIsFromRing(p, r));
204    // omAddr check
205    pPolyAssumeReturnMsg(omTestBinAddrSize(p, (r->PolyBin->sizeW)*SIZEOF_LONG, 1) 
206                     == omError_NoError, "memory error");
207    // number/coef check
208    pPolyAssumeReturnMsg(p->coef != NULL || (n_GetChar(r) >= 2), "NULL coef");
209    pPolyAssumeReturnMsg(!n_IsZero(p->coef, r), "Zero coef");
210
211    // check for mix poly/vec representation
212    pPolyAssumeReturnMsg(ismod == (p_GetComp(p, r) > 0), "mixed poly/vector");
213
214    // special check for ringorder_s/S
215    if (r->order[1] == ringorder_S)
216    {
217      long c1, cc1, ccc1, ec1;
218      sro_ord* o = &(r->typ[1]);
219
220      c1 = p_GetComp(p, r);
221      cc1 = o->data.syzcomp.Components[c1];
222      ccc1 = o->data.syzcomp.ShiftedComponents[cc1];
223      pPolyAssumeReturnMsg(c1 == 0 || cc1 != 0, "Component <-> TrueComponent zero mismatch");
224      pPolyAssumeReturnMsg(c1 == 0 || ccc1 != 0,"Component <-> ShiftedComponent zero mismatch");
225      ec1 = p->exp[r->typ[1].data.syzcomp.place];
226      pPolyAssumeReturnMsg(ec1 == ccc1, "Shifted comp out of sync. should %d, is %d");
227    }
228   
229    // check that p_Setm works ok
230    if (level > 0)
231    {
232      poly p_should_equal = p_DebugInit(p, r, r);
233      pPolyAssumeReturnMsg(p_ExpVectorEqual(p, p_should_equal, r), "p_Setm field(s) out of sync");
234      p_LmFree(p_should_equal, r);
235    }
236   
237    // check order
238    if (p_prev != NULL)
239    {
240      int cmp = p_LmCmp(p_prev, p, r);
241      if (cmp == 0)
242      {
243        _pPolyAssumeReturnMsg(0, "monoms p and p->next are equal", p_prev, r);
244      }
245      else 
246        _pPolyAssumeReturnMsg(p_LmCmp(p_prev, p, r) == 1, "wrong order", p_prev, r);
247
248      // check that compare worked sensibly
249      if (level > 1 && p_GetComp(p_prev, r) == p_GetComp(p, r))
250      {
251        int i;
252        for (i=r->N; i>0; i--)
253        {
254          if (p_GetExp(p_prev, i, r) != p_GetExp(p, i, r)) break;
255        }
256        _pPolyAssumeReturnMsg(i > 0, "Exponents equal but compare different", p_prev, r);
257      }
258    }
259    p_prev = p;
260    pIter(p);
261  }
262  return TRUE;
263}
264
265BOOLEAN _p_LmTest(poly p, ring r, int level)
266{
267  if (level < 0 || p == NULL) return TRUE;
268  poly pnext = pNext(p);
269  pNext(p) = NULL;
270  BOOLEAN test_res = _p_Test(p, r, level);
271  pNext(p) = pnext;
272  return test_res;
273}
274
275BOOLEAN _pp_Test(poly p, ring lmRing, ring tailRing, int level)
276{
277  if (level < 0 || p == NULL) return TRUE;
278  if (pNext(p) == NULL || lmRing == tailRing) return _p_Test(p, lmRing, level);
279
280  pFalseReturn(_p_LmTest(p, lmRing, level));
281  pFalseReturn(_p_Test(pNext(p), tailRing, level));
282
283  // check that lm > Lm(tail)
284  if (level > 1)
285  {
286    poly lm = p;
287    poly tail = p_DebugInit(pNext(p), lmRing, tailRing);
288    poly pnext = pNext(lm);
289    pNext(lm) = tail;
290    BOOLEAN cmp = p_LmCmp(lm, tail, lmRing);
291    if (cmp != 1)
292      dPolyReportError(lm, lmRing, "wrong order: lm <= Lm(tail)");
293    p_LmFree(tail, tailRing);
294    pNext(lm) = pnext;
295    return (cmp == 1);
296  }
297  return TRUE;
298}
299 
300#endif // PDEBUG
301
302#include "pInline1.h"
303
304#if defined(PDEBUG) || defined(PDIV_DEBUG)
305static unsigned long pDivisibleBy_number = 1;
306static unsigned long pDivisibleBy_FALSE = 1;
307static unsigned long pDivisibleBy_ShortFalse = 1;
308BOOLEAN pDebugLmShortDivisibleBy(poly p1, unsigned long sev_1, ring r_1,
309                               poly p2, unsigned long not_sev_2, ring r_2)
310{
311  _pPolyAssume(p_GetShortExpVector(p1, r_1) == sev_1, p1, r_1);
312  _pPolyAssume(p_GetShortExpVector(p2, r_2) == ~ not_sev_2, p2, r_2);
313
314  pDivisibleBy_number++;
315  BOOLEAN ret;
316  if (r_1 == r_2)
317    ret = p_LmDivisibleBy(p1, p2, r_1);
318  else
319    ret = p_LmDivisibleBy(p1, r_1, p2, r_2);
320
321  if (! ret) pDivisibleBy_FALSE++;
322  if (sev_1 & not_sev_2)
323  {
324    pDivisibleBy_ShortFalse++;
325    if (ret)
326      dReportError("p1 divides p2, but sev's are wrong");
327  }
328  return ret;
329}
330
331void pPrintDivisbleByStat()
332{
333  Print("#Tests: %d; #FALSE %d(%d); #SHORT %d(%d)\n",
334        pDivisibleBy_number,
335        pDivisibleBy_FALSE, (unsigned long) ((double)pDivisibleBy_FALSE*((double) 100)/(double)pDivisibleBy_number),
336        pDivisibleBy_ShortFalse, (unsigned long) ((double)pDivisibleBy_ShortFalse*((double)100)/(double)pDivisibleBy_FALSE));
337}
338#endif
339
340#endif // PDEBUG_CC
341
Note: See TracBrowser for help on using the repository browser.