source: git/Singular/misc_ip.cc @ 73fa1c

fieker-DuValspielwiese
Last change on this file since 73fa1c was 73fa1c, checked in by Frank Seelisch <seelisch@…>, 14 years ago
bug fixes resulting from int overflow git-svn-id: file:///usr/local/Singular/svn/trunk@12921 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 25.3 KB
Line 
1/*****************************************************************************\
2 * Computer Algebra System SINGULAR   
3\*****************************************************************************/
4/** @file misc_ip.cc
5 *
6 * This file provides miscellaneous functionality.
7 *
8 * For more general information, see the documentation in
9 * misc_ip.h.
10 *
11 * @author Frank Seelisch
12 *
13 * @internal @version \$Id$
14 *
15 **/
16/*****************************************************************************/
17
18// include header files
19#include "mod2.h"
20#include "lists.h"
21#include "longrat.h" /* We only need bigints. */
22#include "misc_ip.h"
23
24/* This works by Newton iteration, i.e.,
25      a(1)   = n;
26      a(i+1) = a(i)/2 + n/2/a(i), i > 0.
27   This sequence is guaranteed to decrease monotonously and
28   it is known to converge fast.
29   All used numbers are bigints. */
30number approximateSqrt(const number n)
31{
32  if (nlIsZero(n)) { number zero = nlInit(0, NULL); return zero; }
33  number temp1; number temp2;
34  number one = nlInit(1, NULL);
35  number two = nlInit(2, NULL);
36  number m = nlCopy(n);
37  number mOld = nlSub(m, one); /* initially required to be different from m */
38  number nHalf = nlIntDiv(n, two);
39  bool check = true;
40  while (!nlEqual(m, mOld) && check)
41  {
42    temp1 = nlIntDiv(m, two);
43    temp2 = nlIntDiv(nHalf, m);
44    mOld = m;
45    m = nlAdd(temp1, temp2);
46    nlDelete(&temp1, NULL); nlDelete(&temp2, NULL);
47    temp1 = nlMult(m, m);
48    check = nlGreater(temp1, n);
49    nlDelete(&temp1, NULL);
50  }
51  nlDelete(&mOld, NULL); nlDelete(&two, NULL); nlDelete(&nHalf, NULL);
52  while (!check)
53  {
54    temp1 = nlAdd(m, one);
55    nlDelete(&m, NULL);
56    m = temp1;
57    temp1 = nlMult(m, m);
58    check = nlGreater(temp1, n);
59    nlDelete(&temp1, NULL);
60  }
61  temp1 = nlSub(m, one);
62  nlDelete(&m, NULL);
63  nlDelete(&one, NULL);
64  m = temp1;
65  return m;
66}
67
68/* returns the quotient resulting from division of n by the prime as many
69   times as possible without remainder; afterwards, the parameter times
70   will contain the highest exponent e of p such that p^e divides n
71   e.g., divTimes(48, 4, t) = 3 with t = 2, since 48 = 4*4*3;
72   n is expected to be a bigint; returned type is also bigint */
73number divTimes(const number n, const int p, int* times)
74{
75  number nn = nlCopy(n);
76  number dd = nlInit(p, NULL);
77  number rr = nlIntMod(nn, dd);
78  *times = 0;
79  while (nlIsZero(rr))
80  {
81    (*times)++;
82    number temp = nlIntDiv(nn, dd);
83    nlDelete(&nn, NULL);
84    nn = temp;
85    nlDelete(&rr, NULL);
86    rr = nlIntMod(nn, dd);
87  }
88  nlDelete(&rr, NULL); nlDelete(&dd, NULL);
89  return nn;
90}
91
92/* returns an object of type lists which contains the entries
93   theInts[0..(length-1)] as INT_CMDs*/
94lists makeListsObject(const int* theInts, int length)
95{
96  lists L=(lists)omAllocBin(slists_bin);
97  L->Init(length);
98  for (int i = 0; i < length; i++)
99    { L->m[i].rtyp = INT_CMD; L->m[i].data = (void*)theInts[i]; }
100  return L;
101}
102
103/* returns the i-th bit of the binary number which arises by
104   concatenating array[length-1], ..., array[1], array[0],
105   where array[0] contains the 32 lowest bits etc.;
106   i is assumed to be small enough to address a valid index
107   in the given array */
108bool getValue(const int i, const unsigned int* ii)
109{
110  int index = i / 32;
111  int offset = i % 32;
112  unsigned int v = 1 << offset;
113  return ((ii[index] & v) != 0);
114}
115
116/* sets the i-th bit of the binary number which arises by
117   concatenating array[length-1], ..., array[1], array[0],
118   where array[0] contains the 32 lowest bits etc.;
119   i is assumed to be small enough to address a valid index
120   in the given array */
121void setValue(const int i, bool value, unsigned int* ii)
122{
123  int index = i / 32;
124  int offset = i % 32;
125  unsigned int v = 1 << offset;
126  if (value && ((ii[index] & v) != 0)) return;
127  if ((!value) && ((ii[index] & v) == 0)) return;
128  if (value && ((ii[index] & v) == 0)) { ii[index] += v; return; }
129  if ((!value) && ((ii[index] & v) != 0)) { ii[index] -= v; return; }
130}
131
132/* returns whether i is less than or equal to the bigint number n */
133bool isLeq(const int i, const number n)
134{
135  number iN = nlInit(i - 1, NULL);
136  bool result = nlGreater(n, iN);
137  nlDelete(&iN, NULL);
138  return result;
139}
140
141lists primeFactorisation(const number n, const int pBound)
142{
143  number nn = nlCopy(n); int i;
144  int pCounter = 0; /* for counting the number of mutually distinct
145                       prime factors in n */
146  /* we assume that there are at most 1000 mutually distinct prime
147     factors in n */
148  int* primes = new int[1000]; int* multiplicities = new int[1000];
149
150  /* extra treatment for the primes 2 and 3;
151     all other primes are equal to +1/-1 mod 6 */
152  int e; number temp;
153  temp = divTimes(nn, 2, &e); nlDelete(&nn, NULL); nn = temp;
154  if (e > 0) { primes[pCounter] = 2; multiplicities[pCounter++] = e; }
155  temp = divTimes(nn, 3, &e); nlDelete(&nn, NULL); nn = temp;
156  if (e > 0) { primes[pCounter] = 3; multiplicities[pCounter++] = e; }
157
158  /* now we simultaneously:
159     - build the sieve of Erathostenes up to s,
160     - divide out each prime factor of nn that we find along the way
161       (This may result in an earlier termination.) */
162
163  int s = 67108864;       /* = 2^26 */
164  int maxP = 2147483647; /* = 2^31 - 1, by the way a Mersenne prime */
165  if ((pBound != 0) && (pBound < maxP)) maxP = pBound;
166  unsigned int* isPrime = new unsigned int[s];
167  /* the lowest bit of isPrime[0] stores whether 0 is a prime,
168     next bit is for 1, next for 2, etc. i.e.
169     intended usage is: isPrime[0] = 10100000100010100010100010101100.
170     This goes on up to isPrime[67108863]; the highest bit of this
171     unsigned int corresponds to 67108863*32+31 = 2^31-1.
172     We shall make use only of bits which correspond to numbers =
173     -1 or +1 mod 6. */
174  for (i = 0; i < s; i++) isPrime[i] = 4294967295; /* all 32 bits set */
175  int p = 5; bool add2 = true;
176  /* due to possible overflows, we need to check whether p > 0, and
177     likewise i > 0 below */
178  while ((0 < p) && (p <= maxP) && (isLeq(p, nn)))
179  {
180    /* at this point, p is guaranteed to be a prime;
181       we divide nn by the highest power of p and store p
182       if nn is at all divisible by p */
183    temp = divTimes(nn, p, &e);
184    nlDelete(&nn, NULL); nn = temp;
185    if (e > 0) { primes[pCounter] = p; multiplicities[pCounter++] = e; }
186    /* invalidate all multiples of p, starting with 2*p */
187    i = 2 * p;
188    while ((0 < i) && (i <= s)) { setValue(i, false, isPrime); i += p; }
189    /* move on to the next prime in the sieve; we either add 2 or 4
190       in order to visit just the numbers equal to -1/+1 mod 6 */
191    if (add2) { p += 2; add2 = false; }
192    else      { p += 4; add2 = true;  }
193    while ((0 < p) && (p <= maxP) && (isLeq(p, nn)) && (!getValue(p, isPrime)))
194    {
195      if (add2) { p += 2; add2 = false; }
196      else      { p += 4; add2 = true;  }
197    }
198  }
199
200  /* build return structure and clean up */
201  delete [] isPrime;
202  lists primesL = makeListsObject(primes, pCounter);
203  lists multiplicitiesL = makeListsObject(multiplicities, pCounter);
204  delete [] primes; delete [] multiplicities;
205  lists L=(lists)omAllocBin(slists_bin);
206  L->Init(3);
207  L->m[0].rtyp = BIGINT_CMD; L->m[0].data = (void *)nn;
208  /* try to fit nn into an int: */
209  int nnAsInt = nlInt(nn, NULL);
210  if (nlIsZero(nn) || (nnAsInt != 0))
211  { L->m[0].rtyp = INT_CMD; L->m[0].data = (void *)nnAsInt; }
212  L->m[1].rtyp = LIST_CMD; L->m[1].data = (void *)primesL;
213  L->m[2].rtyp = LIST_CMD; L->m[2].data = (void *)multiplicitiesL;
214  return L;
215}
216
217#include <string.h>
218#include <unistd.h>
219#include <stdio.h>
220#include <stddef.h>
221#include <stdlib.h>
222#include <time.h>
223
224#include <mylimits.h>
225#include "omalloc.h"
226#include "options.h"
227#include "febase.h"
228#include "cntrlc.h"
229#include "page.h"
230#include "ipid.h"
231#include "ipshell.h"
232#include "kstd1.h"
233#include "subexpr.h"
234#include "timer.h"
235#include "intvec.h"
236#include "ring.h"
237#include "omSingularConfig.h"
238#include "p_Procs.h"
239/* Needed for debug Version of p_SetRingOfLeftv, Oliver */
240#ifdef PDEBUG
241#include "p_polys.h"
242#endif
243#include "version.h"
244
245#include "static.h"
246#ifdef HAVE_STATIC
247#undef HAVE_DYN_RL
248#endif
249
250#define SI_DONT_HAVE_GLOBAL_VARS
251
252//#ifdef HAVE_LIBPARSER
253//#  include "libparse.h"
254//#endif /* HAVE_LIBPARSER */
255
256#ifdef HAVE_FACTORY
257#include <factory.h>
258// libfac:
259  extern const char * libfac_version;
260  extern const char * libfac_date;
261#endif
262
263/* version strings */
264#include <si_gmp.h>
265#ifdef HAVE_MPSR
266#include <MP_Config.h>
267#endif
268
269/*2
270* initialize components of Singular
271*/
272int inits(void)
273{
274  int t;
275/*4 signal handler:*/
276  init_signals();
277/*4 randomize: */
278  t=initTimer();
279  /*t=(int)time(NULL);*/
280  if (t==0) t=1;
281#ifdef HAVE_RTIMER
282  initRTimer();
283#endif
284#ifdef buildin_rand
285  siSeed=t;
286#else
287  srand((unsigned int)t);
288#endif
289#ifdef HAVE_FACTORY
290  factoryseed(t);
291#endif
292/*4 private data of other modules*/
293  memset(&sLastPrinted,0,sizeof(sleftv));
294  sLastPrinted.rtyp=NONE;
295  return t;
296}
297
298/*2
299* the renice routine for very large jobs
300* works only on unix machines,
301* testet on : linux, HP 9.0
302*
303*#include <sys/times.h>
304*#include <sys/resource.h>
305*extern "C" int setpriority(int,int,int);
306*void very_nice()
307*{
308*#ifndef NO_SETPRIORITY
309*  setpriority(PRIO_PROCESS,0,19);
310*#endif
311*  sleep(10);
312*}
313*/
314
315void singular_example(char *str)
316{
317  assume(str!=NULL);
318  char *s=str;
319  while (*s==' ') s++;
320  char *ss=s;
321  while (*ss!='\0') ss++;
322  while (*ss<=' ')
323  {
324    *ss='\0';
325    ss--;
326  }
327  idhdl h=IDROOT->get(s,myynest);
328  if ((h!=NULL) && (IDTYP(h)==PROC_CMD))
329  {
330    char *lib=iiGetLibName(IDPROC(h));
331    if((lib!=NULL)&&(*lib!='\0'))
332    {
333      Print("// proc %s from lib %s\n",s,lib);
334      s=iiGetLibProcBuffer(IDPROC(h), 2);
335      if (s!=NULL)
336      {
337        if (strlen(s)>5)
338        {
339          iiEStart(s,IDPROC(h));
340          return;
341        }
342        else omFree((ADDRESS)s);
343      }
344    }
345  }
346  else
347  {
348    char sing_file[MAXPATHLEN];
349    FILE *fd=NULL;
350    char *res_m=feResource('m', 0);
351    if (res_m!=NULL)
352    {
353      sprintf(sing_file, "%s/%s.sing", res_m, s);
354      fd = feFopen(sing_file, "r");
355    }
356    if (fd != NULL)
357    {
358
359      int old_echo = si_echo;
360      int length, got;
361      char* s;
362
363      fseek(fd, 0, SEEK_END);
364      length = ftell(fd);
365      fseek(fd, 0, SEEK_SET);
366      s = (char*) omAlloc((length+20)*sizeof(char));
367      got = fread(s, sizeof(char), length, fd);
368      fclose(fd);
369      if (got != length)
370      {
371        Werror("Error while reading file %s", sing_file);
372        omFree(s);
373      }
374      else
375      {
376        s[length] = '\0';
377        strcat(s, "\n;return();\n\n");
378        si_echo = 2;
379        iiEStart(s, NULL);
380        si_echo = old_echo;
381      }
382    }
383    else
384    {
385      Werror("no example for %s", str);
386    }
387  }
388}
389
390
391struct soptionStruct
392{
393  const char * name;
394  unsigned   setval;
395  unsigned   resetval;
396};
397
398struct soptionStruct optionStruct[]=
399{
400  {"prot",         Sy_bit(OPT_PROT),           ~Sy_bit(OPT_PROT)   },
401  {"redSB",        Sy_bit(OPT_REDSB),          ~Sy_bit(OPT_REDSB)   },
402  {"notBuckets",   Sy_bit(OPT_NOT_BUCKETS),    ~Sy_bit(OPT_NOT_BUCKETS)   },
403  {"notSugar",     Sy_bit(OPT_NOT_SUGAR),      ~Sy_bit(OPT_NOT_SUGAR)   },
404  {"interrupt",    Sy_bit(OPT_INTERRUPT),      ~Sy_bit(OPT_INTERRUPT)   },
405  {"sugarCrit",    Sy_bit(OPT_SUGARCRIT),      ~Sy_bit(OPT_SUGARCRIT)   },
406  {"teach",     Sy_bit(OPT_DEBUG),          ~Sy_bit(OPT_DEBUG)  },
407  /* 9 return SB in syz, quotient, intersect */
408  {"returnSB",     Sy_bit(OPT_RETURN_SB),      ~Sy_bit(OPT_RETURN_SB)  },
409  {"fastHC",       Sy_bit(OPT_FASTHC),         ~Sy_bit(OPT_FASTHC)  },
410  /* 11-19 sort in L/T */
411  {"staircaseBound",Sy_bit(OPT_STAIRCASEBOUND),~Sy_bit(OPT_STAIRCASEBOUND)  },
412  {"multBound",    Sy_bit(OPT_MULTBOUND),      ~Sy_bit(OPT_MULTBOUND)  },
413  {"degBound",     Sy_bit(OPT_DEGBOUND),       ~Sy_bit(OPT_DEGBOUND)  },
414  /* 25 no redTail(p)/redTail(s) */
415  {"redTail",      Sy_bit(OPT_REDTAIL),        ~Sy_bit(OPT_REDTAIL)  },
416  {"redThrough",   Sy_bit(OPT_REDTHROUGH),     ~Sy_bit(OPT_REDTHROUGH)  },
417  {"lazy",         Sy_bit(OPT_OLDSTD),         ~Sy_bit(OPT_OLDSTD)  },
418  {"intStrategy",  Sy_bit(OPT_INTSTRATEGY),    ~Sy_bit(OPT_INTSTRATEGY)  },
419  {"infRedTail",   Sy_bit(OPT_INFREDTAIL),     ~Sy_bit(OPT_INFREDTAIL)  },
420  /* 30: use not regularity for syz */
421  {"notRegularity",Sy_bit(OPT_NOTREGULARITY),  ~Sy_bit(OPT_NOTREGULARITY)  },
422  {"weightM",      Sy_bit(OPT_WEIGHTM),        ~Sy_bit(OPT_WEIGHTM)  },
423/*special for "none" and also end marker for showOption:*/
424  {"ne",           0,                          0 }
425};
426
427struct soptionStruct verboseStruct[]=
428{
429  {"mem",      Sy_bit(V_SHOW_MEM),  ~Sy_bit(V_SHOW_MEM)   },
430  {"yacc",     Sy_bit(V_YACC),      ~Sy_bit(V_YACC)       },
431  {"redefine", Sy_bit(V_REDEFINE),  ~Sy_bit(V_REDEFINE)   },
432  {"reading",  Sy_bit(V_READING),   ~Sy_bit(V_READING)    },
433  {"loadLib",  Sy_bit(V_LOAD_LIB),  ~Sy_bit(V_LOAD_LIB)   },
434  {"debugLib", Sy_bit(V_DEBUG_LIB), ~Sy_bit(V_DEBUG_LIB)  },
435  {"loadProc", Sy_bit(V_LOAD_PROC), ~Sy_bit(V_LOAD_PROC)  },
436  {"defRes",   Sy_bit(V_DEF_RES),   ~Sy_bit(V_DEF_RES)    },
437  {"usage",    Sy_bit(V_SHOW_USE),  ~Sy_bit(V_SHOW_USE)   },
438  {"Imap",     Sy_bit(V_IMAP),      ~Sy_bit(V_IMAP)       },
439  {"prompt",   Sy_bit(V_PROMPT),    ~Sy_bit(V_PROMPT)     },
440  {"length",   Sy_bit(V_LENGTH),    ~Sy_bit(V_LENGTH)     },
441  {"notWarnSB",Sy_bit(V_NSB),       ~Sy_bit(V_NSB)        },
442  {"contentSB",Sy_bit(V_CONTENTSB), ~Sy_bit(V_CONTENTSB)  },
443  {"cancelunit",Sy_bit(V_CANCELUNIT),~Sy_bit(V_CANCELUNIT)},
444  {"modpsolve",Sy_bit(V_MODPSOLVSB),~Sy_bit(V_MODPSOLVSB)},
445  {"geometricSB",Sy_bit(V_UPTORADICAL),~Sy_bit(V_UPTORADICAL)},
446  {"findMonomials",Sy_bit(V_FINDMONOM),~Sy_bit(V_FINDMONOM)},
447  {"coefStrat",Sy_bit(V_COEFSTRAT), ~Sy_bit(V_COEFSTRAT)},
448  {"qringNF",  Sy_bit(V_QRING),     ~Sy_bit(V_QRING)},
449/*special for "none" and also end marker for showOption:*/
450  {"ne",         0,          0 }
451};
452
453BOOLEAN setOption(leftv res, leftv v)
454{
455  const char *n;
456  do
457  {
458    if (v->Typ()==STRING_CMD)
459    {
460      n=(const char *)v->CopyD(STRING_CMD);
461    }
462    else
463    {
464      if (v->name==NULL)
465        return TRUE;
466      if (v->rtyp==0)
467      {
468        n=v->name;
469        v->name=NULL;
470      }
471      else
472      {
473        n=omStrDup(v->name);
474      }
475    }
476
477    int i;
478
479    if(strcmp(n,"get")==0)
480    {
481      intvec *w=new intvec(2);
482      (*w)[0]=test;
483      (*w)[1]=verbose;
484      res->rtyp=INTVEC_CMD;
485      res->data=(void *)w;
486      goto okay;
487    }
488    if(strcmp(n,"set")==0)
489    {
490      if((v->next!=NULL)
491      &&(v->next->Typ()==INTVEC_CMD))
492      {
493        v=v->next;
494        intvec *w=(intvec*)v->Data();
495        test=(*w)[0];
496        verbose=(*w)[1];
497#if 0
498        if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
499        && rField_has_simple_inverse()
500#ifdef HAVE_RINGS
501        && !rField_is_Ring(currRing)
502#endif
503        ) {
504          test &=~Sy_bit(OPT_INTSTRATEGY);
505        }
506#endif
507        goto okay;
508      }
509    }
510    if(strcmp(n,"none")==0)
511    {
512      test=0;
513      verbose=0;
514      goto okay;
515    }
516    for (i=0; (i==0) || (optionStruct[i-1].setval!=0); i++)
517    {
518      if (strcmp(n,optionStruct[i].name)==0)
519      {
520        if (optionStruct[i].setval & validOpts)
521        {
522          test |= optionStruct[i].setval;
523          // optOldStd disables redthrough
524          if (optionStruct[i].setval == Sy_bit(OPT_OLDSTD))
525            test &= ~Sy_bit(OPT_REDTHROUGH);
526        }
527        else
528          Warn("cannot set option");
529#if 0
530        if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
531        && rField_has_simple_inverse()
532#ifdef HAVE_RINGS
533        && !rField_is_Ring(currRing)
534#endif
535        ) {
536          test &=~Sy_bit(OPT_INTSTRATEGY);
537        }
538#endif
539        goto okay;
540      }
541      else if ((strncmp(n,"no",2)==0)
542      && (strcmp(n+2,optionStruct[i].name)==0))
543      {
544        if (optionStruct[i].setval & validOpts)
545        {
546          test &= optionStruct[i].resetval;
547        }
548        else
549          Warn("cannot clear option");
550        goto okay;
551      }
552    }
553    for (i=0; (i==0) || (verboseStruct[i-1].setval!=0); i++)
554    {
555      if (strcmp(n,verboseStruct[i].name)==0)
556      {
557        verbose |= verboseStruct[i].setval;
558        #ifdef YYDEBUG
559        #if YYDEBUG
560        /*debugging the bison grammar --> grammar.cc*/
561        extern int    yydebug;
562        if (BVERBOSE(V_YACC)) yydebug=1;
563        else                  yydebug=0;
564        #endif
565        #endif
566        goto okay;
567      }
568      else if ((strncmp(n,"no",2)==0)
569      && (strcmp(n+2,verboseStruct[i].name)==0))
570      {
571        verbose &= verboseStruct[i].resetval;
572        #ifdef YYDEBUG
573        #if YYDEBUG
574        /*debugging the bison grammar --> grammar.cc*/
575        extern int    yydebug;
576        if (BVERBOSE(V_YACC)) yydebug=1;
577        else                  yydebug=0;
578        #endif
579        #endif
580        goto okay;
581      }
582    }
583    Werror("unknown option `%s`",n);
584  okay:
585    if (currRing != NULL)
586      currRing->options = test & TEST_RINGDEP_OPTS;
587    omFree((ADDRESS)n);
588    v=v->next;
589  } while (v!=NULL);
590  #ifdef HAVE_TCL
591    if (tclmode)
592    {
593      BITSET tmp;
594      int i;
595      StringSetS("");
596      if ((test!=0)||(verbose!=0))
597      {
598        tmp=test;
599        if(tmp)
600        {
601          for (i=0; optionStruct[i].setval!=0; i++)
602          {
603            if (optionStruct[i].setval & test)
604            {
605              StringAppend(" %s",optionStruct[i].name);
606              tmp &=optionStruct[i].resetval;
607            }
608          }
609        }
610        tmp=verbose;
611        if (tmp)
612        {
613          for (i=0; verboseStruct[i].setval!=0; i++)
614          {
615            if (verboseStruct[i].setval & tmp)
616            {
617              StringAppend(" %s",verboseStruct[i].name);
618              tmp &=verboseStruct[i].resetval;
619            }
620          }
621        }
622        PrintTCLS('O',StringAppendS(""));
623        StringSetS("");
624      }
625      else
626      {
627        PrintTCLS('O'," ");
628      }
629    }
630  #endif
631    // set global variable to show memory usage
632    if (BVERBOSE(V_SHOW_MEM)) om_sing_opt_show_mem = 1;
633    else om_sing_opt_show_mem = 0;
634  return FALSE;
635}
636
637char * showOption()
638{
639  int i;
640  BITSET tmp;
641
642  StringSetS("//options:");
643  if ((test!=0)||(verbose!=0))
644  {
645    tmp=test;
646    if(tmp)
647    {
648      for (i=0; optionStruct[i].setval!=0; i++)
649      {
650        if (optionStruct[i].setval & test)
651        {
652          StringAppend(" %s",optionStruct[i].name);
653          tmp &=optionStruct[i].resetval;
654        }
655      }
656      for (i=0; i<32; i++)
657      {
658        if (tmp & Sy_bit(i)) StringAppend(" %d",i);
659      }
660    }
661    tmp=verbose;
662    if (tmp)
663    {
664      for (i=0; verboseStruct[i].setval!=0; i++)
665      {
666        if (verboseStruct[i].setval & tmp)
667        {
668          StringAppend(" %s",verboseStruct[i].name);
669          tmp &=verboseStruct[i].resetval;
670        }
671      }
672      for (i=1; i<32; i++)
673      {
674        if (tmp & Sy_bit(i)) StringAppend(" %d",i+32);
675      }
676    }
677    return omStrDup(StringAppendS(""));
678  }
679  else
680    return omStrDup(StringAppendS(" none"));
681}
682
683char * versionString()
684{
685  char* str = StringSetS("");
686  StringAppend("Singular for %s version %s (%d-%lu)  %s\nwith\n",
687               S_UNAME, S_VERSION1, SINGULAR_VERSION,
688               feVersionId,singular_date);
689  StringAppendS("\t");
690#ifdef HAVE_FACTORY
691              StringAppend("factory(%s),", factoryVersion);
692              StringAppend("libfac(%s,%s),\n\t",libfac_version,libfac_date);
693#endif
694#if defined (__GNU_MP_VERSION) && defined (__GNU_MP_VERSION_MINOR)
695              StringAppend("GMP(%d.%d),",__GNU_MP_VERSION,__GNU_MP_VERSION_MINOR);
696#else
697              StringAppendS("GMP(1.3),");
698#endif
699#ifdef HAVE_NTL
700#include "NTL/version.h"
701              StringAppend("NTL(%s),",NTL_VERSION);
702#endif
703#ifdef HAVE_MPSR
704              StringAppend("MP(%s),",MP_VERSION);
705#endif
706#if SIZEOF_VOIDP == 8
707              StringAppendS("64bit,");
708#else
709              StringAppendS("32bit,");
710#endif
711#if defined(HAVE_DYN_RL)
712              if (fe_fgets_stdin==fe_fgets_dummy)
713                StringAppendS("no input,");
714              else if (fe_fgets_stdin==fe_fgets)
715                StringAppendS("fgets,");
716              if (fe_fgets_stdin==fe_fgets_stdin_drl)
717                StringAppendS("dynamic readline,");
718              #ifdef HAVE_FEREAD
719              else if (fe_fgets_stdin==fe_fgets_stdin_emu)
720                StringAppendS("emulated readline,");
721              #endif
722              else
723                StringAppendS("unknown fgets method,");
724#else
725  #if defined(HAVE_READLINE) && !defined(FEREAD)
726              StringAppendS("static readline,");
727  #else
728    #ifdef HAVE_FEREAD
729              StringAppendS("emulated readline,");
730    #else
731              StringAppendS("fgets,");
732    #endif
733  #endif
734#endif
735#ifdef HAVE_PLURAL
736              StringAppendS("Plural,");
737#endif
738#ifdef HAVE_DBM
739              StringAppendS("DBM,\n\t");
740#else
741              StringAppendS("\n\t");
742#endif
743#ifdef HAVE_DYNAMIC_LOADING
744              StringAppendS("dynamic modules,");
745#endif
746              if (p_procs_dynamic) StringAppendS("dynamic p_Procs,");
747#ifdef TEST
748              StringAppendS("TESTs,");
749#endif
750#if YYDEBUG
751              StringAppendS("YYDEBUG=1,");
752#endif
753#ifdef HAVE_ASSUME
754             StringAppendS("ASSUME,");
755#endif
756#ifdef MDEBUG
757              StringAppend("MDEBUG=%d,",MDEBUG);
758#endif
759#ifdef OM_CHECK
760              StringAppend("OM_CHECK=%d,",OM_CHECK);
761#endif
762#ifdef OM_TRACK
763              StringAppend("OM_TRACK=%d,",OM_TRACK);
764#endif
765#ifdef OM_NDEBUG
766              StringAppendS("OM_NDEBUG,");
767#endif
768#ifdef PDEBUG
769              StringAppendS("PDEBUG,");
770#endif
771#ifdef KDEBUG
772              StringAppendS("KDEBUG,");
773#endif
774#ifndef __OPTIMIZE__
775              StringAppendS("-g,");
776#endif
777#ifdef HAVE_EIGENVAL
778              StringAppendS("eigenvalues,");
779#endif
780#ifdef HAVE_GMS
781              StringAppendS("Gauss-Manin system,");
782#endif
783#ifdef HAVE_RATGRING
784              StringAppendS("ratGB,");
785#endif
786              StringAppend("random=%d\n",siRandomStart);
787              StringAppend("\tCC=%s,\n\tCXX=%s"
788#ifdef __GNUC__
789              "(" __VERSION__ ")"
790#endif
791              "\n",CC,CXX);
792              feStringAppendResources(0);
793              feStringAppendBrowsers(0);
794              StringAppendS("\n");
795              return str;
796}
797
798#ifdef PDEBUG
799#if (OM_TRACK > 2) && defined(OM_TRACK_CUSTOM)
800void p_SetRingOfLeftv(leftv l, ring r)
801{
802  switch(l->rtyp)
803  {
804    case INT_CMD:
805    case BIGINT_CMD:
806    case IDHDL:
807    case DEF_CMD:
808      break;
809    case POLY_CMD:
810    case VECTOR_CMD:
811    {
812      poly p=(poly)l->data;
813      while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
814      break;
815    }
816    case IDEAL_CMD:
817    case MODUL_CMD:
818    case MATRIX_CMD:
819    {
820      ideal I=(ideal)l->data;
821      int i;
822      for(i=IDELEMS(I)-1;i>=0;i--)
823      {
824        poly p=I->m[i];
825        while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
826      }
827      break;
828    }
829    case COMMAND:
830    {
831      command d=(command)l->data;
832      p_SetRingOfLeftv(&d->arg1, r);
833      if (d->argc>1) p_SetRingOfLeftv(&d->arg2, r);
834      if (d->argc>2) p_SetRingOfLeftv(&d->arg3, r);
835      break;
836    }
837    default:
838     printf("type %d not yet implementd in p_SetRingOfLeftv\n",l->rtyp);
839     break;
840  }
841}
842#endif
843#endif
844
845void listall(int showproc)
846{
847      idhdl hh=basePack->idroot;
848      PrintS("====== Top ==============\n");
849      while (hh!=NULL)
850      {
851        if (showproc || (IDTYP(hh)!=PROC_CMD))
852        {
853          if (IDDATA(hh)==(void *)currRing) PrintS("(R)");
854          else if (IDDATA(hh)==(void *)currPack) PrintS("(P)");
855          else PrintS("   ");
856          Print("::%s, typ %s level %d data %lx",
857                 IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
858          if ((IDTYP(hh)==RING_CMD)
859          || (IDTYP(hh)==QRING_CMD))
860            Print(" ref: %d\n",IDRING(hh)->ref);
861          else
862            PrintLn();
863        }
864        hh=IDNEXT(hh);
865      }
866      hh=basePack->idroot;
867      while (hh!=NULL)
868      {
869        if (IDDATA(hh)==(void *)basePack)
870          Print("(T)::%s, typ %s level %d data %lx\n",
871          IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
872        else
873        if ((IDTYP(hh)==RING_CMD)
874        || (IDTYP(hh)==QRING_CMD)
875        || (IDTYP(hh)==PACKAGE_CMD))
876        {
877          Print("====== %s ==============\n",IDID(hh));
878          idhdl h2=IDRING(hh)->idroot;
879          while (h2!=NULL)
880          {
881            if (showproc || (IDTYP(h2)!=PROC_CMD))
882            {
883              if ((IDDATA(h2)==(void *)currRing)
884              && ((IDTYP(h2)==RING_CMD)||(IDTYP(h2)==QRING_CMD)))
885                PrintS("(R)");
886              else if (IDDATA(h2)==(void *)currPack) PrintS("(P)");
887              else PrintS("   ");
888              Print("%s::%s, typ %s level %d data %lx\n",
889              IDID(hh),IDID(h2),Tok2Cmdname(IDTYP(h2)),IDLEV(h2),(long)IDDATA(h2));
890            }
891            h2=IDNEXT(h2);
892          }
893        }
894        hh=IDNEXT(hh);
895      }
896      Print("currRing:%lx, currPack:%lx,basePack:%lx\n",(long)currRing,(long)currPack,(long)basePack);
897      iiCheckPack(currPack);
898}
899#ifndef NDEBUG
900void checkall()
901{
902      idhdl hh=basePack->idroot;
903      while (hh!=NULL)
904      {
905        omCheckAddr(hh);
906        omCheckAddr((ADDRESS)IDID(hh));
907        if (RingDependend(IDTYP(hh))) Print("%s typ %d in Top\n",IDID(hh),IDTYP(hh));
908        hh=IDNEXT(hh);
909      }
910      hh=basePack->idroot;
911      while (hh!=NULL)
912      {
913        if (IDTYP(hh)==PACKAGE_CMD)
914        {
915          idhdl h2=IDPACKAGE(hh)->idroot;
916          while (h2!=NULL)
917          {
918            omCheckAddr(h2);
919            omCheckAddr((ADDRESS)IDID(h2));
920            if (RingDependend(IDTYP(h2))) Print("%s typ %d in %s\n",IDID(h2),IDTYP(h2),IDID(hh));
921            h2=IDNEXT(h2);
922          }
923        }
924        hh=IDNEXT(hh);
925      }
926}
927#endif
928
929#include <sys/types.h>
930#include <sys/stat.h>
931#include <unistd.h>
932
933extern "C"
934int singular_fstat(int fd, struct stat *buf)
935{
936  return fstat(fd,buf);
937}
938
Note: See TracBrowser for help on using the repository browser.