source: git/Singular/misc_ip.cc @ 03ac3b

spielwiese
Last change on this file since 03ac3b was 03ac3b, checked in by Hans Schoenemann <hannes@…>, 14 years ago
primefactors: limits git-svn-id: file:///usr/local/Singular/svn/trunk@13385 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 26.6 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 <kernel/mod2.h>
20#include <Singular/lists.h>
21#include <kernel/longrat.h>
22#include <Singular/misc_ip.h>
23
24void number2mpz(number n, mpz_t m)
25{
26  if (SR_HDL(n) & SR_INT) mpz_init_set_si(m, SR_TO_INT(n));     /* n fits in an int */
27  else             mpz_init_set(m, (mpz_ptr)n->z);
28}
29
30number mpz2number(mpz_t m)
31{
32  number z = (number)omAllocBin(rnumber_bin);
33  mpz_init_set(z->z, m);
34  mpz_init_set_ui(z->n, 1);
35  z->s = 3;
36  return z;
37}
38
39void divTimes(mpz_t n, mpz_t d, int* times)
40{
41  *times = 0;
42  mpz_t r; mpz_init(r);
43  mpz_t q; mpz_init(q);
44  mpz_fdiv_qr(q, r, n, d);
45  while (mpz_cmp_ui(r, 0) == 0)
46  {
47    (*times)++;
48    mpz_set(n, q);
49    mpz_fdiv_qr(q, r, n, d);
50  }
51  mpz_clear(r);
52  mpz_clear(q);
53}
54
55void divTimes_ui(mpz_t n, unsigned long d, int* times)
56{
57  *times = 0;
58  mpz_t r; mpz_init(r);
59  mpz_t q; mpz_init(q);
60  mpz_fdiv_qr_ui(q, r, n, d);
61  while (mpz_cmp_ui(r, 0) == 0)
62  {
63    (*times)++;
64    mpz_set(n, q);
65    mpz_fdiv_qr_ui(q, r, n, d);
66  }
67  mpz_clear(r);
68  mpz_clear(q);
69}
70
71static inline void divTimes_ui_ui(unsigned long *n, unsigned long d, int* times)
72{
73  *times = 0;
74  unsigned long q=(*n) / d;
75  unsigned long r=(*n) % d;
76  while (r==0)
77  {
78    (*times)++;
79    (*n)=q;
80    q=(*n)/d; r=(*n)%d;
81  }
82}
83
84/* returns an object of type lists which contains the entries
85   theInts[0..(length-1)] as INT_CMDs */
86lists makeListsObject(const int* theInts, int length)
87{
88  lists L=(lists)omAllocBin(slists_bin);
89  L->Init(length);
90  for (int i = 0; i < length; i++)
91    { L->m[i].rtyp = INT_CMD; L->m[i].data = (void*)theInts[i]; }
92  return L;
93}
94
95void setListEntry(lists L, int index, mpz_t n)
96{ /* assumes n > 0 */
97  /* try to fit nn into an int: */
98  if (mpz_size1(n)<=1)
99  {
100    int ui=(int)mpz_get_si(n);
101    if ((((ui<<3)>>3)==ui)
102    && (mpz_cmp_si(n,(long)ui)==0))
103    {
104      L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)ui;
105      return;
106    }
107  }
108  number nn = mpz2number(n);
109  L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
110}
111
112void setListEntry_ui(lists L, int index, unsigned long ui)
113{ /* assumes n > 0 */
114  /* try to fit nn into an int: */
115  int i=(int)ui;
116  if ((((unsigned long)i)==ui) && (((i<<3)>>3)==i))
117  {
118    L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)i;
119  }
120  else
121  {
122    number nn = nlRInit(ui);
123    mpz_set_ui(nn->z,ui);
124    L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
125  }
126}
127
128/* true iff p is prime */
129/*
130bool isPrime(mpz_t p)
131{
132  if (mpz_cmp_ui(p, 2) == 0) return true;
133  if (mpz_cmp_ui(p, 3) == 0) return true;
134  if (mpz_cmp_ui(p, 5) < 0)  return false;
135
136  mpz_t d; mpz_init_set_ui(d, 5); int add = 2;
137  mpz_t sr; mpz_init(sr); mpz_sqrt(sr, p);
138  mpz_t r; mpz_init(r);
139  while (mpz_cmp(d, sr) <= 0)
140  {
141    mpz_cdiv_r(r, p, d);
142    if (mpz_cmp_ui(r, 0) == 0)
143    {
144      mpz_clear(d); mpz_clear(sr); mpz_clear(r);
145      return false;
146    }
147    mpz_add_ui(d, d, add);
148    add += 2; if (add == 6) add = 2;
149  }
150  mpz_clear(d); mpz_clear(sr); mpz_clear(r);
151  return true;
152}
153*/
154
155/* finds the next prime q, bound >= q >= p;
156   in case of success, puts q into p;
157   otherwise sets q = bound + 1;
158   e.g. p = 24; nextPrime(p, 30) produces p = 29 (success),
159        p = 24; nextPrime(p, 29) produces p = 29 (success),
160        p = 24; nextPrime(p, 28) produces p = 29 (no success),
161        p = 24; nextPrime(p, 27) produces p = 28 (no success) */
162/*
163void nextPrime(mpz_t p, mpz_t bound)
164{
165  int add;
166  mpz_t r; mpz_init(r); mpz_cdiv_r_ui(r, p, 6); // r = p mod 6, 0 <= r <= 5
167  if (mpz_cmp_ui(r, 0) == 0) { mpz_add_ui(p, p, 1); add = 4; }
168  if (mpz_cmp_ui(r, 1) == 0) {                      add = 4; }
169  if (mpz_cmp_ui(r, 2) == 0) { mpz_add_ui(p, p, 3); add = 2; }
170  if (mpz_cmp_ui(r, 3) == 0) { mpz_add_ui(p, p, 2); add = 2; }
171  if (mpz_cmp_ui(r, 4) == 0) { mpz_add_ui(p, p, 1); add = 2; }
172  if (mpz_cmp_ui(r, 5) == 0) {                      add = 2; }
173
174  while (mpz_cmp(p, bound) <= 0)
175  {
176    if (isPrime(p)) { mpz_clear(r); return; }
177    mpz_add_ui(p, p, add);
178    add += 2; if (add == 6) add = 2;
179  }
180  mpz_set(p, bound);
181  mpz_add_ui(p, p, 1);
182  mpz_clear(r);
183  return;
184}
185*/
186
187/* n and pBound are assumed to be bigint numbers */
188lists primeFactorisation(const number n, number pBound)
189{
190  mpz_t nn; number2mpz(n, nn);
191  mpz_t pb; number2mpz(pBound, pb);
192  mpz_t b; number2mpz(pBound, b);
193  mpz_t p; mpz_init(p); int tt;
194  mpz_t sr; mpz_init(sr); int index = 0; int add;
195  lists primes = (lists)omAllocBin(slists_bin); primes->Init(1000);
196  int* multiplicities = new int[1000];
197  int positive=1; int probTest = 0;
198
199  if (!nlIsZero(n))
200  {
201    if (!nlGreaterZero(n))
202    {
203      positive=-1;
204      mpz_neg(nn,nn);
205    }
206    divTimes_ui(nn, 2, &tt);
207    if (tt > 0)
208    {
209      setListEntry_ui(primes, index, 2);
210      multiplicities[index++] = tt;
211    }
212
213    divTimes_ui(nn, 3, &tt);
214    if (tt > 0)
215    {
216      setListEntry_ui(primes, index, 3);
217      multiplicities[index++] = tt;
218    }
219
220    unsigned long p_ui=5; add = 2;
221    mpz_sqrt(sr, nn);
222    unsigned long  limit=nlInt(pBound,NULL);
223    if ((mpz_cmp_ui(b, 0) == 0) || (mpz_cmp(pb, sr) > 0)) 
224    {
225      mpz_set(pb, sr);
226      mpz_set(b, sr);
227      limit=mpz_get_ui(sr);
228    }
229    else if (limit==0)
230    {
231      limit=1<<31;
232      mpz_set_ui(pb,limit);
233      mpz_set_ui(b,limit);
234    }
235    while (p_ui <=limit)
236    {
237      divTimes_ui(nn, p_ui, &tt);
238      if (tt > 0)
239      {
240        setListEntry_ui(primes, index, p_ui);
241        multiplicities[index++] = tt;
242        //mpz_sqrt(sr, nn);
243        //if ((mpz_cmp_ui(b, 0) == 0) || (mpz_cmp(pb, sr) > 0)) mpz_set(pb, sr);
244        if (mpz_size1(nn)<=1)
245        {
246          mpz_sqrt(sr, nn);
247          if (mpz_cmp(pb, sr) > 0) mpz_set(pb, sr);
248          unsigned long l=mpz_get_ui(sr);
249          if (l<limit) { limit=l; }
250          if (mpz_size1(nn)<=1)
251          {
252            unsigned long nn_ui=mpz_get_ui(nn);
253            while ((p_ui <=limit)&&(nn_ui>1))
254            {
255              divTimes_ui_ui(&nn_ui, p_ui, &tt);
256              if (tt > 0)
257              {
258                setListEntry_ui(primes, index, p_ui);
259                multiplicities[index++] = tt;
260                if (nn_ui<(limit/6)) { limit=nn_ui/6;}
261              }
262              p_ui +=add;
263              add += 2; if (add == 6) add = 2;
264            }
265            mpz_set_ui(nn,nn_ui);
266            break;
267          }
268        }
269      }
270      p_ui +=add;
271      add += 2; if (add == 6) add = 2;
272    }
273    mpz_set_ui(p, p_ui);
274    mpz_sqrt(sr, nn);
275    if ((mpz_cmp_ui(b, 0) == 0) || (mpz_cmp(pb, sr) > 0)) mpz_set(pb, sr);
276    while (mpz_cmp(pb, p) >= 0)
277    {
278      divTimes(nn, p, &tt);
279      if (tt > 0)
280      {
281        setListEntry(primes, index, p);
282        multiplicities[index++] = tt;
283        mpz_sqrt(sr, nn);
284        if ((mpz_cmp_ui(b, 0) == 0) || (mpz_cmp(pb, sr) > 0)) mpz_set(pb, sr);
285      }
286      mpz_add_ui(p, p, add);
287      add += 2; if (add == 6) add = 2;
288    }
289    if ((mpz_cmp_ui(nn, 1) > 0) &&
290        ((mpz_cmp_ui(b, 0) == 0) || (mpz_cmp(nn, b) <= 0)))
291    {
292      setListEntry(primes, index, nn);
293      multiplicities[index++] = 1;
294      mpz_set_ui(nn, 1);
295    }
296    if ((mpz_cmp_ui(nn, 1) > 0) && (mpz_probab_prime_p(nn, 25) != 0))
297      probTest = 1;
298  }
299
300  lists primesL = (lists)omAllocBin(slists_bin);
301  primesL->Init(index);
302  for (int i = 0; i < index; i++)
303  {
304    primesL->m[i].rtyp = primes->m[i].rtyp;
305    primesL->m[i].data = primes->m[i].data;
306  }
307  omFreeSize((ADDRESS)primes->m, (primes->nr + 1) * sizeof(sleftv));
308  omFreeBin((ADDRESS)primes, slists_bin);
309
310  lists multiplicitiesL = (lists)omAllocBin(slists_bin);
311  multiplicitiesL->Init(index);
312  for (int i = 0; i < index; i++)
313  {
314    multiplicitiesL->m[i].rtyp = INT_CMD;
315    multiplicitiesL->m[i].data = (void*)multiplicities[i];
316  }
317  delete[] multiplicities;
318
319  lists L=(lists)omAllocBin(slists_bin);
320  L->Init(4);
321  if (positive==-1) mpz_neg(nn,nn);
322  L->m[0].rtyp = LIST_CMD; L->m[0].data = (void*)primesL;
323  L->m[1].rtyp = LIST_CMD; L->m[1].data = (void*)multiplicitiesL;
324  setListEntry(L, 2, nn);
325  L->m[3].rtyp =  INT_CMD; L->m[3].data = (void*)probTest;
326  mpz_clear(nn); mpz_clear(pb); mpz_clear(b); mpz_clear(p); mpz_clear(sr);
327
328  return L;
329}
330
331#include <string.h>
332#include <unistd.h>
333#include <stdio.h>
334#include <stddef.h>
335#include <stdlib.h>
336#include <time.h>
337
338#include <omalloc/mylimits.h>
339#include <omalloc/omalloc.h>
340#include <kernel/options.h>
341#include <kernel/febase.h>
342#include <Singular/cntrlc.h>
343#include <kernel/page.h>
344#include <Singular/ipid.h>
345#include <Singular/ipshell.h>
346#include <kernel/kstd1.h>
347#include <Singular/subexpr.h>
348#include <kernel/timer.h>
349#include <kernel/intvec.h>
350#include <kernel/ring.h>
351#include <Singular/omSingularConfig.h>
352#include <kernel/p_Procs.h>
353/* Needed for debug Version of p_SetRingOfLeftv, Oliver */
354#ifdef PDEBUG
355#include <kernel/polys.h>
356#endif
357#include <Singular/version.h>
358
359#include <Singular/static.h>
360#ifdef HAVE_STATIC
361#undef HAVE_DYN_RL
362#endif
363
364#define SI_DONT_HAVE_GLOBAL_VARS
365
366//#ifdef HAVE_LIBPARSER
367//#  include "libparse.h"
368//#endif /* HAVE_LIBPARSER */
369
370#ifdef HAVE_FACTORY
371#include <factory/factory.h>
372// libfac:
373  extern const char * libfac_version;
374  extern const char * libfac_date;
375#endif
376
377/* version strings */
378#include <kernel/si_gmp.h>
379#ifdef HAVE_MPSR
380#include <MP_Config.h>
381#endif
382
383/*2
384* initialize components of Singular
385*/
386int inits(void)
387{
388  int t;
389/*4 signal handler:*/
390  init_signals();
391/*4 randomize: */
392  t=initTimer();
393  /*t=(int)time(NULL);*/
394  if (t==0) t=1;
395#ifdef HAVE_RTIMER
396  initRTimer();
397#endif
398#ifdef buildin_rand
399  siSeed=t;
400#else
401  srand((unsigned int)t);
402#endif
403#ifdef HAVE_FACTORY
404  factoryseed(t);
405#endif
406/*4 private data of other modules*/
407  memset(&sLastPrinted,0,sizeof(sleftv));
408  sLastPrinted.rtyp=NONE;
409  return t;
410}
411
412/*2
413* the renice routine for very large jobs
414* works only on unix machines,
415* testet on : linux, HP 9.0
416*
417*#include <sys/times.h>
418*#include <sys/resource.h>
419*extern "C" int setpriority(int,int,int);
420*void very_nice()
421*{
422*#ifndef NO_SETPRIORITY
423*  setpriority(PRIO_PROCESS,0,19);
424*#endif
425*  sleep(10);
426*}
427*/
428
429void singular_example(char *str)
430{
431  assume(str!=NULL);
432  char *s=str;
433  while (*s==' ') s++;
434  char *ss=s;
435  while (*ss!='\0') ss++;
436  while (*ss<=' ')
437  {
438    *ss='\0';
439    ss--;
440  }
441  idhdl h=IDROOT->get(s,myynest);
442  if ((h!=NULL) && (IDTYP(h)==PROC_CMD))
443  {
444    char *lib=iiGetLibName(IDPROC(h));
445    if((lib!=NULL)&&(*lib!='\0'))
446    {
447      Print("// proc %s from lib %s\n",s,lib);
448      s=iiGetLibProcBuffer(IDPROC(h), 2);
449      if (s!=NULL)
450      {
451        if (strlen(s)>5)
452        {
453          iiEStart(s,IDPROC(h));
454          return;
455        }
456        else omFree((ADDRESS)s);
457      }
458    }
459  }
460  else
461  {
462    char sing_file[MAXPATHLEN];
463    FILE *fd=NULL;
464    char *res_m=feResource('m', 0);
465    if (res_m!=NULL)
466    {
467      sprintf(sing_file, "%s/%s.sing", res_m, s);
468      fd = feFopen(sing_file, "r");
469    }
470    if (fd != NULL)
471    {
472
473      int old_echo = si_echo;
474      int length, got;
475      char* s;
476
477      fseek(fd, 0, SEEK_END);
478      length = ftell(fd);
479      fseek(fd, 0, SEEK_SET);
480      s = (char*) omAlloc((length+20)*sizeof(char));
481      got = fread(s, sizeof(char), length, fd);
482      fclose(fd);
483      if (got != length)
484      {
485        Werror("Error while reading file %s", sing_file);
486        omFree(s);
487      }
488      else
489      {
490        s[length] = '\0';
491        strcat(s, "\n;return();\n\n");
492        si_echo = 2;
493        iiEStart(s, NULL);
494        si_echo = old_echo;
495      }
496    }
497    else
498    {
499      Werror("no example for %s", str);
500    }
501  }
502}
503
504
505struct soptionStruct
506{
507  const char * name;
508  unsigned   setval;
509  unsigned   resetval;
510};
511
512struct soptionStruct optionStruct[]=
513{
514  {"prot",         Sy_bit(OPT_PROT),           ~Sy_bit(OPT_PROT)   },
515  {"redSB",        Sy_bit(OPT_REDSB),          ~Sy_bit(OPT_REDSB)   },
516  {"notBuckets",   Sy_bit(OPT_NOT_BUCKETS),    ~Sy_bit(OPT_NOT_BUCKETS)   },
517  {"notSugar",     Sy_bit(OPT_NOT_SUGAR),      ~Sy_bit(OPT_NOT_SUGAR)   },
518  {"interrupt",    Sy_bit(OPT_INTERRUPT),      ~Sy_bit(OPT_INTERRUPT)   },
519  {"sugarCrit",    Sy_bit(OPT_SUGARCRIT),      ~Sy_bit(OPT_SUGARCRIT)   },
520  {"teach",     Sy_bit(OPT_DEBUG),          ~Sy_bit(OPT_DEBUG)  },
521  /* 9 return SB in syz, quotient, intersect */
522  {"returnSB",     Sy_bit(OPT_RETURN_SB),      ~Sy_bit(OPT_RETURN_SB)  },
523  {"fastHC",       Sy_bit(OPT_FASTHC),         ~Sy_bit(OPT_FASTHC)  },
524  /* 11-19 sort in L/T */
525  {"staircaseBound",Sy_bit(OPT_STAIRCASEBOUND),~Sy_bit(OPT_STAIRCASEBOUND)  },
526  {"multBound",    Sy_bit(OPT_MULTBOUND),      ~Sy_bit(OPT_MULTBOUND)  },
527  {"degBound",     Sy_bit(OPT_DEGBOUND),       ~Sy_bit(OPT_DEGBOUND)  },
528  /* 25 no redTail(p)/redTail(s) */
529  {"redTail",      Sy_bit(OPT_REDTAIL),        ~Sy_bit(OPT_REDTAIL)  },
530  {"redThrough",   Sy_bit(OPT_REDTHROUGH),     ~Sy_bit(OPT_REDTHROUGH)  },
531  {"lazy",         Sy_bit(OPT_OLDSTD),         ~Sy_bit(OPT_OLDSTD)  },
532  {"intStrategy",  Sy_bit(OPT_INTSTRATEGY),    ~Sy_bit(OPT_INTSTRATEGY)  },
533  {"infRedTail",   Sy_bit(OPT_INFREDTAIL),     ~Sy_bit(OPT_INFREDTAIL)  },
534  /* 30: use not regularity for syz */
535  {"notRegularity",Sy_bit(OPT_NOTREGULARITY),  ~Sy_bit(OPT_NOTREGULARITY)  },
536  {"weightM",      Sy_bit(OPT_WEIGHTM),        ~Sy_bit(OPT_WEIGHTM)  },
537/*special for "none" and also end marker for showOption:*/
538  {"ne",           0,                          0 }
539};
540
541struct soptionStruct verboseStruct[]=
542{
543  {"mem",      Sy_bit(V_SHOW_MEM),  ~Sy_bit(V_SHOW_MEM)   },
544  {"yacc",     Sy_bit(V_YACC),      ~Sy_bit(V_YACC)       },
545  {"redefine", Sy_bit(V_REDEFINE),  ~Sy_bit(V_REDEFINE)   },
546  {"reading",  Sy_bit(V_READING),   ~Sy_bit(V_READING)    },
547  {"loadLib",  Sy_bit(V_LOAD_LIB),  ~Sy_bit(V_LOAD_LIB)   },
548  {"debugLib", Sy_bit(V_DEBUG_LIB), ~Sy_bit(V_DEBUG_LIB)  },
549  {"loadProc", Sy_bit(V_LOAD_PROC), ~Sy_bit(V_LOAD_PROC)  },
550  {"defRes",   Sy_bit(V_DEF_RES),   ~Sy_bit(V_DEF_RES)    },
551  {"usage",    Sy_bit(V_SHOW_USE),  ~Sy_bit(V_SHOW_USE)   },
552  {"Imap",     Sy_bit(V_IMAP),      ~Sy_bit(V_IMAP)       },
553  {"prompt",   Sy_bit(V_PROMPT),    ~Sy_bit(V_PROMPT)     },
554  {"length",   Sy_bit(V_LENGTH),    ~Sy_bit(V_LENGTH)     },
555  {"notWarnSB",Sy_bit(V_NSB),       ~Sy_bit(V_NSB)        },
556  {"contentSB",Sy_bit(V_CONTENTSB), ~Sy_bit(V_CONTENTSB)  },
557  {"cancelunit",Sy_bit(V_CANCELUNIT),~Sy_bit(V_CANCELUNIT)},
558  {"modpsolve",Sy_bit(V_MODPSOLVSB),~Sy_bit(V_MODPSOLVSB)},
559  {"geometricSB",Sy_bit(V_UPTORADICAL),~Sy_bit(V_UPTORADICAL)},
560  {"findMonomials",Sy_bit(V_FINDMONOM),~Sy_bit(V_FINDMONOM)},
561  {"coefStrat",Sy_bit(V_COEFSTRAT), ~Sy_bit(V_COEFSTRAT)},
562  {"qringNF",  Sy_bit(V_QRING),     ~Sy_bit(V_QRING)},
563  {"warn",     Sy_bit(V_ALLWARN),   ~Sy_bit(V_ALLWARN)},
564/*special for "none" and also end marker for showOption:*/
565  {"ne",         0,          0 }
566};
567
568BOOLEAN setOption(leftv res, leftv v)
569{
570  const char *n;
571  do
572  {
573    if (v->Typ()==STRING_CMD)
574    {
575      n=(const char *)v->CopyD(STRING_CMD);
576    }
577    else
578    {
579      if (v->name==NULL)
580        return TRUE;
581      if (v->rtyp==0)
582      {
583        n=v->name;
584        v->name=NULL;
585      }
586      else
587      {
588        n=omStrDup(v->name);
589      }
590    }
591
592    int i;
593
594    if(strcmp(n,"get")==0)
595    {
596      intvec *w=new intvec(2);
597      (*w)[0]=test;
598      (*w)[1]=verbose;
599      res->rtyp=INTVEC_CMD;
600      res->data=(void *)w;
601      goto okay;
602    }
603    if(strcmp(n,"set")==0)
604    {
605      if((v->next!=NULL)
606      &&(v->next->Typ()==INTVEC_CMD))
607      {
608        v=v->next;
609        intvec *w=(intvec*)v->Data();
610        test=(*w)[0];
611        verbose=(*w)[1];
612#if 0
613        if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
614        && rField_has_simple_inverse()
615#ifdef HAVE_RINGS
616        && !rField_is_Ring(currRing)
617#endif
618        ) {
619          test &=~Sy_bit(OPT_INTSTRATEGY);
620        }
621#endif
622        goto okay;
623      }
624    }
625    if(strcmp(n,"none")==0)
626    {
627      test=0;
628      verbose=0;
629      goto okay;
630    }
631    for (i=0; (i==0) || (optionStruct[i-1].setval!=0); i++)
632    {
633      if (strcmp(n,optionStruct[i].name)==0)
634      {
635        if (optionStruct[i].setval & validOpts)
636        {
637          test |= optionStruct[i].setval;
638          // optOldStd disables redthrough
639          if (optionStruct[i].setval == Sy_bit(OPT_OLDSTD))
640            test &= ~Sy_bit(OPT_REDTHROUGH);
641        }
642        else
643          Warn("cannot set option");
644#if 0
645        if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
646        && rField_has_simple_inverse()
647#ifdef HAVE_RINGS
648        && !rField_is_Ring(currRing)
649#endif
650        ) {
651          test &=~Sy_bit(OPT_INTSTRATEGY);
652        }
653#endif
654        goto okay;
655      }
656      else if ((strncmp(n,"no",2)==0)
657      && (strcmp(n+2,optionStruct[i].name)==0))
658      {
659        if (optionStruct[i].setval & validOpts)
660        {
661          test &= optionStruct[i].resetval;
662        }
663        else
664          Warn("cannot clear option");
665        goto okay;
666      }
667    }
668    for (i=0; (i==0) || (verboseStruct[i-1].setval!=0); i++)
669    {
670      if (strcmp(n,verboseStruct[i].name)==0)
671      {
672        verbose |= verboseStruct[i].setval;
673        #ifdef YYDEBUG
674        #if YYDEBUG
675        /*debugging the bison grammar --> grammar.cc*/
676        extern int    yydebug;
677        if (BVERBOSE(V_YACC)) yydebug=1;
678        else                  yydebug=0;
679        #endif
680        #endif
681        goto okay;
682      }
683      else if ((strncmp(n,"no",2)==0)
684      && (strcmp(n+2,verboseStruct[i].name)==0))
685      {
686        verbose &= verboseStruct[i].resetval;
687        #ifdef YYDEBUG
688        #if YYDEBUG
689        /*debugging the bison grammar --> grammar.cc*/
690        extern int    yydebug;
691        if (BVERBOSE(V_YACC)) yydebug=1;
692        else                  yydebug=0;
693        #endif
694        #endif
695        goto okay;
696      }
697    }
698    Werror("unknown option `%s`",n);
699  okay:
700    if (currRing != NULL)
701      currRing->options = test & TEST_RINGDEP_OPTS;
702    omFree((ADDRESS)n);
703    v=v->next;
704  } while (v!=NULL);
705  // set global variable to show memory usage
706  if (BVERBOSE(V_SHOW_MEM)) om_sing_opt_show_mem = 1;
707  else om_sing_opt_show_mem = 0;
708  return FALSE;
709}
710
711char * showOption()
712{
713  int i;
714  BITSET tmp;
715
716  StringSetS("//options:");
717  if ((test!=0)||(verbose!=0))
718  {
719    tmp=test;
720    if(tmp)
721    {
722      for (i=0; optionStruct[i].setval!=0; i++)
723      {
724        if (optionStruct[i].setval & test)
725        {
726          StringAppend(" %s",optionStruct[i].name);
727          tmp &=optionStruct[i].resetval;
728        }
729      }
730      for (i=0; i<32; i++)
731      {
732        if (tmp & Sy_bit(i)) StringAppend(" %d",i);
733      }
734    }
735    tmp=verbose;
736    if (tmp)
737    {
738      for (i=0; verboseStruct[i].setval!=0; i++)
739      {
740        if (verboseStruct[i].setval & tmp)
741        {
742          StringAppend(" %s",verboseStruct[i].name);
743          tmp &=verboseStruct[i].resetval;
744        }
745      }
746      for (i=1; i<32; i++)
747      {
748        if (tmp & Sy_bit(i)) StringAppend(" %d",i+32);
749      }
750    }
751    return omStrDup(StringAppendS(""));
752  }
753  else
754    return omStrDup(StringAppendS(" none"));
755}
756
757char * versionString()
758{
759  char* str = StringSetS("");
760  StringAppend("Singular for %s version %s (%d-%s)  %s\nwith\n",
761               S_UNAME, S_VERSION1, SINGULAR_VERSION,
762               feVersionId,singular_date);
763  StringAppendS("\t");
764#ifdef HAVE_FACTORY
765              StringAppend("factory(%s),", factoryVersion);
766              StringAppend("libfac(%s,%s),\n\t",libfac_version,libfac_date);
767#endif
768#if defined (__GNU_MP_VERSION) && defined (__GNU_MP_VERSION_MINOR)
769              StringAppend("GMP(%d.%d),",__GNU_MP_VERSION,__GNU_MP_VERSION_MINOR);
770#else
771              StringAppendS("GMP(1.3),");
772#endif
773#ifdef HAVE_NTL
774#include <NTL/version.h>
775              StringAppend("NTL(%s),",NTL_VERSION);
776#endif
777#ifdef HAVE_MPSR
778              StringAppend("MP(%s),",MP_VERSION);
779#endif
780#if SIZEOF_VOIDP == 8
781              StringAppendS("64bit,");
782#else
783              StringAppendS("32bit,");
784#endif
785#if defined(HAVE_DYN_RL)
786              if (fe_fgets_stdin==fe_fgets_dummy)
787                StringAppendS("no input,");
788              else if (fe_fgets_stdin==fe_fgets)
789                StringAppendS("fgets,");
790              if (fe_fgets_stdin==fe_fgets_stdin_drl)
791                StringAppendS("dynamic readline,");
792              #ifdef HAVE_FEREAD
793              else if (fe_fgets_stdin==fe_fgets_stdin_emu)
794                StringAppendS("emulated readline,");
795              #endif
796              else
797                StringAppendS("unknown fgets method,");
798#else
799  #if defined(HAVE_READLINE) && !defined(FEREAD)
800              StringAppendS("static readline,");
801  #else
802    #ifdef HAVE_FEREAD
803              StringAppendS("emulated readline,");
804    #else
805              StringAppendS("fgets,");
806    #endif
807  #endif
808#endif
809#ifdef HAVE_PLURAL
810              StringAppendS("Plural,");
811#endif
812#ifdef HAVE_DBM
813              StringAppendS("DBM,\n\t");
814#else
815              StringAppendS("\n\t");
816#endif
817#ifdef HAVE_DYNAMIC_LOADING
818              StringAppendS("dynamic modules,");
819#endif
820              if (p_procs_dynamic) StringAppendS("dynamic p_Procs,");
821#ifdef TEST
822              StringAppendS("TESTs,");
823#endif
824#if YYDEBUG
825              StringAppendS("YYDEBUG=1,");
826#endif
827#ifdef HAVE_ASSUME
828             StringAppendS("ASSUME,");
829#endif
830#ifdef MDEBUG
831              StringAppend("MDEBUG=%d,",MDEBUG);
832#endif
833#ifdef OM_CHECK
834              StringAppend("OM_CHECK=%d,",OM_CHECK);
835#endif
836#ifdef OM_TRACK
837              StringAppend("OM_TRACK=%d,",OM_TRACK);
838#endif
839#ifdef OM_NDEBUG
840              StringAppendS("OM_NDEBUG,");
841#endif
842#ifdef PDEBUG
843              StringAppendS("PDEBUG,");
844#endif
845#ifdef KDEBUG
846              StringAppendS("KDEBUG,");
847#endif
848#ifndef __OPTIMIZE__
849              StringAppendS("-g,");
850#endif
851#ifdef HAVE_EIGENVAL
852              StringAppendS("eigenvalues,");
853#endif
854#ifdef HAVE_GMS
855              StringAppendS("Gauss-Manin system,");
856#endif
857#ifdef HAVE_RATGRING
858              StringAppendS("ratGB,");
859#endif
860              StringAppend("random=%d\n",siRandomStart);
861              StringAppend("\tCC=%s,\n\tCXX=%s"
862#ifdef __GNUC__
863              "(" __VERSION__ ")"
864#endif
865              "\n",CC,CXX);
866              feStringAppendResources(0);
867              feStringAppendBrowsers(0);
868              StringAppendS("\n");
869              return str;
870}
871
872#ifdef PDEBUG
873#if (OM_TRACK > 2) && defined(OM_TRACK_CUSTOM)
874void p_SetRingOfLeftv(leftv l, ring r)
875{
876  switch(l->rtyp)
877  {
878    case INT_CMD:
879    case BIGINT_CMD:
880    case IDHDL:
881    case DEF_CMD:
882      break;
883    case POLY_CMD:
884    case VECTOR_CMD:
885    {
886      poly p=(poly)l->data;
887      while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
888      break;
889    }
890    case IDEAL_CMD:
891    case MODUL_CMD:
892    case MATRIX_CMD:
893    {
894      ideal I=(ideal)l->data;
895      int i;
896      for(i=IDELEMS(I)-1;i>=0;i--)
897      {
898        poly p=I->m[i];
899        while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
900      }
901      break;
902    }
903    case COMMAND:
904    {
905      command d=(command)l->data;
906      p_SetRingOfLeftv(&d->arg1, r);
907      if (d->argc>1) p_SetRingOfLeftv(&d->arg2, r);
908      if (d->argc>2) p_SetRingOfLeftv(&d->arg3, r);
909      break;
910    }
911    default:
912     printf("type %d not yet implementd in p_SetRingOfLeftv\n",l->rtyp);
913     break;
914  }
915}
916#endif
917#endif
918
919void listall(int showproc)
920{
921      idhdl hh=basePack->idroot;
922      PrintS("====== Top ==============\n");
923      while (hh!=NULL)
924      {
925        if (showproc || (IDTYP(hh)!=PROC_CMD))
926        {
927          if (IDDATA(hh)==(void *)currRing) PrintS("(R)");
928          else if (IDDATA(hh)==(void *)currPack) PrintS("(P)");
929          else PrintS("   ");
930          Print("::%s, typ %s level %d data %lx",
931                 IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
932          if ((IDTYP(hh)==RING_CMD)
933          || (IDTYP(hh)==QRING_CMD))
934            Print(" ref: %d\n",IDRING(hh)->ref);
935          else
936            PrintLn();
937        }
938        hh=IDNEXT(hh);
939      }
940      hh=basePack->idroot;
941      while (hh!=NULL)
942      {
943        if (IDDATA(hh)==(void *)basePack)
944          Print("(T)::%s, typ %s level %d data %lx\n",
945          IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
946        else
947        if ((IDTYP(hh)==RING_CMD)
948        || (IDTYP(hh)==QRING_CMD)
949        || (IDTYP(hh)==PACKAGE_CMD))
950        {
951          Print("====== %s ==============\n",IDID(hh));
952          idhdl h2=IDRING(hh)->idroot;
953          while (h2!=NULL)
954          {
955            if (showproc || (IDTYP(h2)!=PROC_CMD))
956            {
957              if ((IDDATA(h2)==(void *)currRing)
958              && ((IDTYP(h2)==RING_CMD)||(IDTYP(h2)==QRING_CMD)))
959                PrintS("(R)");
960              else if (IDDATA(h2)==(void *)currPack) PrintS("(P)");
961              else PrintS("   ");
962              Print("%s::%s, typ %s level %d data %lx\n",
963              IDID(hh),IDID(h2),Tok2Cmdname(IDTYP(h2)),IDLEV(h2),(long)IDDATA(h2));
964            }
965            h2=IDNEXT(h2);
966          }
967        }
968        hh=IDNEXT(hh);
969      }
970      Print("currRing:%lx, currPack:%lx,basePack:%lx\n",(long)currRing,(long)currPack,(long)basePack);
971      iiCheckPack(currPack);
972}
973#ifndef NDEBUG
974void checkall()
975{
976      idhdl hh=basePack->idroot;
977      while (hh!=NULL)
978      {
979        omCheckAddr(hh);
980        omCheckAddr((ADDRESS)IDID(hh));
981        if (RingDependend(IDTYP(hh))) Print("%s typ %d in Top\n",IDID(hh),IDTYP(hh));
982        hh=IDNEXT(hh);
983      }
984      hh=basePack->idroot;
985      while (hh!=NULL)
986      {
987        if (IDTYP(hh)==PACKAGE_CMD)
988        {
989          idhdl h2=IDPACKAGE(hh)->idroot;
990          while (h2!=NULL)
991          {
992            omCheckAddr(h2);
993            omCheckAddr((ADDRESS)IDID(h2));
994            if (RingDependend(IDTYP(h2))) Print("%s typ %d in %s\n",IDID(h2),IDTYP(h2),IDID(hh));
995            h2=IDNEXT(h2);
996          }
997        }
998        hh=IDNEXT(hh);
999      }
1000}
1001#endif
1002
1003#include <sys/types.h>
1004#include <sys/stat.h>
1005#include <unistd.h>
1006
1007extern "C"
1008int singular_fstat(int fd, struct stat *buf)
1009{
1010  return fstat(fd,buf);
1011}
1012
1013/*2
1014* the global exit routine of Singular
1015*/
1016#ifdef HAVE_MPSR
1017void (*MP_Exit_Env_Ptr)()=NULL;
1018#endif
1019
1020extern "C" {
1021
1022void m2_end(int i)
1023{
1024  fe_reset_input_mode();
1025  #ifdef PAGE_TEST
1026  mmEndStat();
1027  #endif
1028  fe_reset_input_mode();
1029  idhdl h = IDROOT;
1030  while(h != NULL)
1031  {
1032    if(IDTYP(h) == LINK_CMD)
1033    {
1034      idhdl hh=h->next;
1035      killhdl(h, currPack);
1036      h = hh;
1037    }
1038    else
1039    {
1040      h = h->next;
1041    }
1042  }
1043  if (i<=0)
1044  {
1045      if (TEST_V_QUIET)
1046      {
1047        if (i==0)
1048          printf("Auf Wiedersehen.\n");
1049        else
1050          printf("\n$Bye.\n");
1051      }
1052    //#ifdef sun
1053    //  #ifndef __svr4__
1054    //    _cleanup();
1055    //    _exit(0);
1056    //  #endif
1057    //#endif
1058    exit(0);
1059  }
1060  else
1061  {
1062      printf("\nhalt %d\n",i);
1063  }
1064  #ifdef HAVE_MPSR
1065  if (MP_Exit_Env_Ptr!=NULL) (*MP_Exit_Env_Ptr)();
1066  #endif
1067  exit(i);
1068}
1069}
Note: See TracBrowser for help on using the repository browser.