source: git/Singular/misc_ip.cc @ 3645fc

spielwiese
Last change on this file since 3645fc was 3645fc, checked in by Hans Schoenemann <hannes@…>, 13 years ago
init via siInit git-svn-id: file:///usr/local/Singular/svn/trunk@14268 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 29.2 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#include <Singular/feOpt.h>
24#include <Singular/silink.h>
25
26void number2mpz(number n, mpz_t m)
27{
28  if (SR_HDL(n) & SR_INT) mpz_init_set_si(m, SR_TO_INT(n));     /* n fits in an int */
29  else             mpz_init_set(m, (mpz_ptr)n->z);
30}
31
32number mpz2number(mpz_t m)
33{
34  number z = (number)omAllocBin(rnumber_bin);
35  mpz_init_set(z->z, m);
36  mpz_init_set_ui(z->n, 1);
37  z->s = 3;
38  return z;
39}
40
41void divTimes(mpz_t n, mpz_t d, int* times)
42{
43  *times = 0;
44  mpz_t r; mpz_init(r);
45  mpz_t q; mpz_init(q);
46  mpz_fdiv_qr(q, r, n, d);
47  while (mpz_cmp_ui(r, 0) == 0)
48  {
49    (*times)++;
50    mpz_set(n, q);
51    mpz_fdiv_qr(q, r, n, d);
52  }
53  mpz_clear(r);
54  mpz_clear(q);
55}
56
57void divTimes_ui(mpz_t n, unsigned long d, int* times)
58{
59  *times = 0;
60  mpz_t r; mpz_init(r);
61  mpz_t q; mpz_init(q);
62  mpz_fdiv_qr_ui(q, r, n, d);
63  while (mpz_cmp_ui(r, 0) == 0)
64  {
65    (*times)++;
66    mpz_set(n, q);
67    mpz_fdiv_qr_ui(q, r, n, d);
68  }
69  mpz_clear(r);
70  mpz_clear(q);
71}
72
73static inline void divTimes_ui_ui(unsigned long *n, unsigned long d, int* times)
74{
75  *times = 0;
76  unsigned long q=(*n) / d;
77  unsigned long r=(*n) % d;
78  while (r==0)
79  {
80    (*times)++;
81    (*n)=q;
82    q=(*n)/d; r=(*n)%d;
83  }
84}
85
86void setListEntry(lists L, int index, mpz_t n)
87{ /* assumes n > 0 */
88  /* try to fit nn into an int: */
89  if (mpz_size1(n)<=1)
90  {
91    int ui=(int)mpz_get_si(n);
92    if ((((ui<<3)>>3)==ui)
93    && (mpz_cmp_si(n,(long)ui)==0))
94    {
95      L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)ui;
96      return;
97    }
98  }
99  number nn = mpz2number(n);
100  L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
101}
102
103void setListEntry_ui(lists L, int index, unsigned long ui)
104{ /* assumes n > 0 */
105  /* try to fit nn into an int: */
106  int i=(int)ui;
107  if ((((unsigned long)i)==ui) && (((i<<3)>>3)==i))
108  {
109    L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)i;
110  }
111  else
112  {
113    number nn = nlRInit(ui);
114    mpz_set_ui(nn->z,ui);
115    L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
116  }
117}
118
119/* true iff p is prime */
120/*
121bool isPrime(mpz_t p)
122{
123  if (mpz_cmp_ui(p, 2) == 0) return true;
124  if (mpz_cmp_ui(p, 3) == 0) return true;
125  if (mpz_cmp_ui(p, 5) < 0)  return false;
126
127  mpz_t d; mpz_init_set_ui(d, 5); int add = 2;
128  mpz_t sr; mpz_init(sr); mpz_sqrt(sr, p);
129  mpz_t r; mpz_init(r);
130  while (mpz_cmp(d, sr) <= 0)
131  {
132    mpz_cdiv_r(r, p, d);
133    if (mpz_cmp_ui(r, 0) == 0)
134    {
135      mpz_clear(d); mpz_clear(sr); mpz_clear(r);
136      return false;
137    }
138    mpz_add_ui(d, d, add);
139    add += 2; if (add == 6) add = 2;
140  }
141  mpz_clear(d); mpz_clear(sr); mpz_clear(r);
142  return true;
143}
144*/
145
146/* finds the next prime q, bound >= q >= p;
147   in case of success, puts q into p;
148   otherwise sets q = bound + 1;
149   e.g. p = 24; nextPrime(p, 30) produces p = 29 (success),
150        p = 24; nextPrime(p, 29) produces p = 29 (success),
151        p = 24; nextPrime(p, 28) produces p = 29 (no success),
152        p = 24; nextPrime(p, 27) produces p = 28 (no success) */
153/*
154void nextPrime(mpz_t p, mpz_t bound)
155{
156  int add;
157  mpz_t r; mpz_init(r); mpz_cdiv_r_ui(r, p, 6); // r = p mod 6, 0 <= r <= 5
158  if (mpz_cmp_ui(r, 0) == 0) { mpz_add_ui(p, p, 1); add = 4; }
159  if (mpz_cmp_ui(r, 1) == 0) {                      add = 4; }
160  if (mpz_cmp_ui(r, 2) == 0) { mpz_add_ui(p, p, 3); add = 2; }
161  if (mpz_cmp_ui(r, 3) == 0) { mpz_add_ui(p, p, 2); add = 2; }
162  if (mpz_cmp_ui(r, 4) == 0) { mpz_add_ui(p, p, 1); add = 2; }
163  if (mpz_cmp_ui(r, 5) == 0) {                      add = 2; }
164
165  while (mpz_cmp(p, bound) <= 0)
166  {
167    if (isPrime(p)) { mpz_clear(r); return; }
168    mpz_add_ui(p, p, add);
169    add += 2; if (add == 6) add = 2;
170  }
171  mpz_set(p, bound);
172  mpz_add_ui(p, p, 1);
173  mpz_clear(r);
174  return;
175}
176*/
177
178/* n and pBound are assumed to be bigint numbers */
179lists primeFactorisation(const number n, const number pBound)
180{
181  mpz_t nn; number2mpz(n, nn);
182  mpz_t pb; number2mpz(pBound, pb);
183  mpz_t b; number2mpz(pBound, b);
184  mpz_t p; mpz_init(p); int tt;
185  mpz_t sr; mpz_init(sr); int index = 0; int add;
186  lists primes = (lists)omAllocBin(slists_bin); primes->Init(1000);
187  int* multiplicities = new int[1000];
188  int positive=1; int probTest = 0;
189
190  if (!nlIsZero(n))
191  {
192    if (!nlGreaterZero(n))
193    {
194      positive=-1;
195      mpz_neg(nn,nn);
196    }
197    divTimes_ui(nn, 2, &tt);
198    if (tt > 0)
199    {
200      setListEntry_ui(primes, index, 2);
201      multiplicities[index++] = tt;
202    }
203
204    divTimes_ui(nn, 3, &tt);
205    if (tt > 0)
206    {
207      setListEntry_ui(primes, index, 3);
208      multiplicities[index++] = tt;
209    }
210
211    unsigned long p_ui=5; add = 2;
212    BOOLEAN b_is_0=(mpz_cmp_ui(b, 0) == 0);
213    BOOLEAN sr_sets_pb=FALSE;
214    mpz_sqrt(sr, nn);
215    // there are 3 possible limits, we take the minimum:
216    // - argument pBound (if >0)
217    // - sr = sqrt(nn)
218    // - 1<<31
219    unsigned long  limit=~(0L);
220    if (b_is_0 || (mpz_cmp(pb, sr) > 0))
221    {
222      mpz_set(pb, sr);
223      sr_sets_pb=TRUE;
224    }
225    if (mpz_cmp_ui(pb, limit)<0)
226    {
227     limit=mpz_get_ui(pb);
228    }
229    else
230    {
231      mpz_set_ui(pb,limit);
232    }
233    while (p_ui <=limit)
234    {
235      divTimes_ui(nn, p_ui, &tt);
236      if (tt > 0)
237      {
238        setListEntry_ui(primes, index, p_ui);
239        multiplicities[index++] = tt;
240        //mpz_sqrt(sr, nn);
241        //if ((mpz_cmp_ui(b, 0) == 0) || (mpz_cmp(pb, sr) > 0)) mpz_set(pb, sr);
242        if (mpz_size1(nn)<=2)
243        {
244          mpz_sqrt(sr, nn);
245          if (sr_sets_pb || (mpz_cmp(pb, sr) > 0)) mpz_set(pb, sr);
246          unsigned long l=mpz_get_ui(sr);
247          if (l<limit) { limit=l; }
248          if (mpz_size1(nn)<=1)
249          {
250            unsigned long nn_ui=mpz_get_ui(nn);
251            while (p_ui <=limit)
252            {
253              divTimes_ui_ui(&nn_ui, p_ui, &tt);
254              if (tt > 0)
255              {
256                setListEntry_ui(primes, index, p_ui);
257                multiplicities[index++] = tt;
258                if (nn_ui==1) break;
259                if (nn_ui<(limit/6)) { limit=nn_ui/6;}
260              }
261              p_ui +=add;
262              //add += 2; if (add == 6) add = 2;
263              add =2+2*(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      add =2+2*(add==2);
273    }
274    mpz_set_ui(p, p_ui);
275    mpz_sqrt(sr, nn);
276    if (b_is_0 || sr_sets_pb || (mpz_cmp(pb, sr) > 0)) mpz_set(pb, sr);
277    while (mpz_cmp(pb, p) >= 0)
278    {
279      divTimes(nn, p, &tt);
280      if (tt > 0)
281      {
282        setListEntry(primes, index, p);
283        multiplicities[index++] = tt;
284        if (mpz_cmp_ui(nn,1)==0) break;
285        mpz_sqrt(sr, nn);
286        if (b_is_0 || sr_sets_pb || (mpz_cmp(pb, sr) > 0)) mpz_set(pb, sr);
287      }
288      mpz_add_ui(p, p, add);
289      //add += 2; if (add == 6) add = 2;
290      add =2+2*(add==2);
291    }
292    if ((mpz_cmp_ui(nn, 1) > 0) &&
293        (b_is_0 || (mpz_cmp(nn, b) <= 0)))
294    {
295      setListEntry(primes, index, nn);
296      multiplicities[index++] = 1;
297      mpz_set_ui(nn, 1);
298    }
299    if ((mpz_cmp_ui(nn, 1) > 0) && (mpz_probab_prime_p(nn, 25) != 0))
300      probTest = 1;
301  }
302
303  lists primesL = (lists)omAllocBin(slists_bin);
304  primesL->Init(index);
305  for (int i = 0; i < index; i++)
306  {
307    primesL->m[i].rtyp = primes->m[i].rtyp;
308    primesL->m[i].data = primes->m[i].data;
309  }
310  omFreeSize((ADDRESS)primes->m, (primes->nr + 1) * sizeof(sleftv));
311  omFreeBin((ADDRESS)primes, slists_bin);
312
313  lists multiplicitiesL = (lists)omAllocBin(slists_bin);
314  multiplicitiesL->Init(index);
315  for (int i = 0; i < index; i++)
316  {
317    multiplicitiesL->m[i].rtyp = INT_CMD;
318    multiplicitiesL->m[i].data = (void*)multiplicities[i];
319  }
320  delete[] multiplicities;
321
322  lists L=(lists)omAllocBin(slists_bin);
323  L->Init(4);
324  if (positive==-1) mpz_neg(nn,nn);
325  L->m[0].rtyp = LIST_CMD; L->m[0].data = (void*)primesL;
326  L->m[1].rtyp = LIST_CMD; L->m[1].data = (void*)multiplicitiesL;
327  setListEntry(L, 2, nn);
328  L->m[3].rtyp =  INT_CMD; L->m[3].data = (void*)probTest;
329  mpz_clear(nn); mpz_clear(pb); mpz_clear(b); mpz_clear(p); mpz_clear(sr);
330
331  return L;
332}
333
334#include <string.h>
335#include <unistd.h>
336#include <stdio.h>
337#include <stddef.h>
338#include <stdlib.h>
339#include <time.h>
340
341#include <omalloc/mylimits.h>
342#include <omalloc/omalloc.h>
343#include <kernel/options.h>
344#include <kernel/febase.h>
345#include <Singular/cntrlc.h>
346#include <kernel/page.h>
347#include <Singular/ipid.h>
348#include <Singular/ipshell.h>
349#include <kernel/kstd1.h>
350#include <Singular/subexpr.h>
351#include <kernel/timer.h>
352#include <kernel/intvec.h>
353#include <kernel/ring.h>
354#include <kernel/p_Procs.h>
355/* Needed for debug Version of p_SetRingOfLeftv, Oliver */
356#ifdef PDEBUG
357#include <kernel/polys.h>
358#endif
359#include <Singular/version.h>
360
361#include <Singular/static.h>
362#ifdef HAVE_STATIC
363#undef HAVE_DYN_RL
364#endif
365
366#define SI_DONT_HAVE_GLOBAL_VARS
367
368//#ifdef HAVE_LIBPARSER
369//#  include "libparse.h"
370//#endif /* HAVE_LIBPARSER */
371
372#ifdef HAVE_FACTORY
373#define SI_DONT_HAVE_GLOBAL_VARS
374#include <factory/factory.h>
375// libfac:
376  extern const char * libfac_version;
377  extern const char * libfac_date;
378#endif
379
380/* version strings */
381#include <kernel/si_gmp.h>
382#ifdef HAVE_MPSR
383#include <MP_Config.h>
384#endif
385
386/*2
387* initialize components of Singular
388*/
389int inits(void)
390{
391  int t;
392/*4 signal handler:*/
393  init_signals();
394/*4 randomize: */
395  t=initTimer();
396  /*t=(int)time(NULL);*/
397  if (t==0) t=1;
398  initRTimer();
399  siSeed=t;
400#ifdef HAVE_FACTORY
401  factoryseed(t);
402#endif
403/*4 private data of other modules*/
404  memset(&sLastPrinted,0,sizeof(sleftv));
405  sLastPrinted.rtyp=NONE;
406  return t;
407}
408
409/*2
410* the renice routine for very large jobs
411* works only on unix machines,
412* testet on : linux, HP 9.0
413*
414*#include <sys/times.h>
415*#include <sys/resource.h>
416*extern "C" int setpriority(int,int,int);
417*void very_nice()
418*{
419*#ifndef NO_SETPRIORITY
420*  setpriority(PRIO_PROCESS,0,19);
421*#endif
422*  sleep(10);
423*}
424*/
425
426void singular_example(char *str)
427{
428  assume(str!=NULL);
429  char *s=str;
430  while (*s==' ') s++;
431  char *ss=s;
432  while (*ss!='\0') ss++;
433  while (*ss<=' ')
434  {
435    *ss='\0';
436    ss--;
437  }
438  idhdl h=IDROOT->get(s,myynest);
439  if ((h!=NULL) && (IDTYP(h)==PROC_CMD))
440  {
441    char *lib=iiGetLibName(IDPROC(h));
442    if((lib!=NULL)&&(*lib!='\0'))
443    {
444      Print("// proc %s from lib %s\n",s,lib);
445      s=iiGetLibProcBuffer(IDPROC(h), 2);
446      if (s!=NULL)
447      {
448        if (strlen(s)>5)
449        {
450          iiEStart(s,IDPROC(h));
451          return;
452        }
453        else omFree((ADDRESS)s);
454      }
455    }
456  }
457  else
458  {
459    char sing_file[MAXPATHLEN];
460    FILE *fd=NULL;
461    char *res_m=feResource('m', 0);
462    if (res_m!=NULL)
463    {
464      sprintf(sing_file, "%s/%s.sing", res_m, s);
465      fd = feFopen(sing_file, "r");
466    }
467    if (fd != NULL)
468    {
469
470      int old_echo = si_echo;
471      int length, got;
472      char* s;
473
474      fseek(fd, 0, SEEK_END);
475      length = ftell(fd);
476      fseek(fd, 0, SEEK_SET);
477      s = (char*) omAlloc((length+20)*sizeof(char));
478      got = fread(s, sizeof(char), length, fd);
479      fclose(fd);
480      if (got != length)
481      {
482        Werror("Error while reading file %s", sing_file);
483        omFree(s);
484      }
485      else
486      {
487        s[length] = '\0';
488        strcat(s, "\n;return();\n\n");
489        si_echo = 2;
490        iiEStart(s, NULL);
491        si_echo = old_echo;
492      }
493    }
494    else
495    {
496      Werror("no example for %s", str);
497    }
498  }
499}
500
501
502struct soptionStruct
503{
504  const char * name;
505  unsigned   setval;
506  unsigned   resetval;
507};
508
509struct soptionStruct optionStruct[]=
510{
511  {"prot",         Sy_bit(OPT_PROT),           ~Sy_bit(OPT_PROT)   },
512  {"redSB",        Sy_bit(OPT_REDSB),          ~Sy_bit(OPT_REDSB)   },
513  {"notBuckets",   Sy_bit(OPT_NOT_BUCKETS),    ~Sy_bit(OPT_NOT_BUCKETS)   },
514  {"notSugar",     Sy_bit(OPT_NOT_SUGAR),      ~Sy_bit(OPT_NOT_SUGAR)   },
515  {"interrupt",    Sy_bit(OPT_INTERRUPT),      ~Sy_bit(OPT_INTERRUPT)   },
516  {"sugarCrit",    Sy_bit(OPT_SUGARCRIT),      ~Sy_bit(OPT_SUGARCRIT)   },
517  {"teach",        Sy_bit(OPT_DEBUG),          ~Sy_bit(OPT_DEBUG)  },
518  {"notSyzMinim",  Sy_bit(OPT_NO_SYZ_MINIM),   ~Sy_bit(OPT_NO_SYZ_MINIM)  },
519  /* 9 return SB in syz, quotient, intersect */
520  {"returnSB",     Sy_bit(OPT_RETURN_SB),      ~Sy_bit(OPT_RETURN_SB)  },
521  {"fastHC",       Sy_bit(OPT_FASTHC),         ~Sy_bit(OPT_FASTHC)  },
522  /* 11-19 sort in L/T */
523  {"staircaseBound",Sy_bit(OPT_STAIRCASEBOUND),~Sy_bit(OPT_STAIRCASEBOUND)  },
524  {"multBound",    Sy_bit(OPT_MULTBOUND),      ~Sy_bit(OPT_MULTBOUND)  },
525  {"degBound",     Sy_bit(OPT_DEGBOUND),       ~Sy_bit(OPT_DEGBOUND)  },
526  /* 25 no redTail(p)/redTail(s) */
527  {"redTail",      Sy_bit(OPT_REDTAIL),        ~Sy_bit(OPT_REDTAIL)  },
528  {"redThrough",   Sy_bit(OPT_REDTHROUGH),     ~Sy_bit(OPT_REDTHROUGH)  },
529  {"lazy",         Sy_bit(OPT_OLDSTD),         ~Sy_bit(OPT_OLDSTD)  },
530  {"intStrategy",  Sy_bit(OPT_INTSTRATEGY),    ~Sy_bit(OPT_INTSTRATEGY)  },
531  {"infRedTail",   Sy_bit(OPT_INFREDTAIL),     ~Sy_bit(OPT_INFREDTAIL)  },
532  /* 30: use not regularity for syz */
533  {"notRegularity",Sy_bit(OPT_NOTREGULARITY),  ~Sy_bit(OPT_NOTREGULARITY)  },
534  {"weightM",      Sy_bit(OPT_WEIGHTM),        ~Sy_bit(OPT_WEIGHTM)  },
535/*special for "none" and also end marker for showOption:*/
536  {"ne",           0,                          0 }
537};
538
539struct soptionStruct verboseStruct[]=
540{
541  {"mem",      Sy_bit(V_SHOW_MEM),  ~Sy_bit(V_SHOW_MEM)   },
542  {"yacc",     Sy_bit(V_YACC),      ~Sy_bit(V_YACC)       },
543  {"redefine", Sy_bit(V_REDEFINE),  ~Sy_bit(V_REDEFINE)   },
544  {"reading",  Sy_bit(V_READING),   ~Sy_bit(V_READING)    },
545  {"loadLib",  Sy_bit(V_LOAD_LIB),  ~Sy_bit(V_LOAD_LIB)   },
546  {"debugLib", Sy_bit(V_DEBUG_LIB), ~Sy_bit(V_DEBUG_LIB)  },
547  {"loadProc", Sy_bit(V_LOAD_PROC), ~Sy_bit(V_LOAD_PROC)  },
548  {"defRes",   Sy_bit(V_DEF_RES),   ~Sy_bit(V_DEF_RES)    },
549  {"usage",    Sy_bit(V_SHOW_USE),  ~Sy_bit(V_SHOW_USE)   },
550  {"Imap",     Sy_bit(V_IMAP),      ~Sy_bit(V_IMAP)       },
551  {"prompt",   Sy_bit(V_PROMPT),    ~Sy_bit(V_PROMPT)     },
552  {"length",   Sy_bit(V_LENGTH),    ~Sy_bit(V_LENGTH)     },
553  {"notWarnSB",Sy_bit(V_NSB),       ~Sy_bit(V_NSB)        },
554  {"contentSB",Sy_bit(V_CONTENTSB), ~Sy_bit(V_CONTENTSB)  },
555  {"cancelunit",Sy_bit(V_CANCELUNIT),~Sy_bit(V_CANCELUNIT)},
556  {"modpsolve",Sy_bit(V_MODPSOLVSB),~Sy_bit(V_MODPSOLVSB)},
557  {"geometricSB",Sy_bit(V_UPTORADICAL),~Sy_bit(V_UPTORADICAL)},
558  {"findMonomials",Sy_bit(V_FINDMONOM),~Sy_bit(V_FINDMONOM)},
559  {"coefStrat",Sy_bit(V_COEFSTRAT), ~Sy_bit(V_COEFSTRAT)},
560  {"qringNF",  Sy_bit(V_QRING),     ~Sy_bit(V_QRING)},
561  {"warn",     Sy_bit(V_ALLWARN),   ~Sy_bit(V_ALLWARN)},
562  {"interedSyz",Sy_bit(V_INTERSECT_SYZ), ~Sy_bit(V_INTERSECT_SYZ)},
563  {"interedElim",Sy_bit(V_INTERSECT_ELIM), ~Sy_bit(V_INTERSECT_ELIM)},
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  extern int om_sing_opt_show_mem;
707  if (BVERBOSE(V_SHOW_MEM)) om_sing_opt_show_mem = 1;
708  else om_sing_opt_show_mem = 0;
709  return FALSE;
710}
711
712char * showOption()
713{
714  int i;
715  BITSET tmp;
716
717  StringSetS("//options:");
718  if ((test!=0)||(verbose!=0))
719  {
720    tmp=test;
721    if(tmp)
722    {
723      for (i=0; optionStruct[i].setval!=0; i++)
724      {
725        if (optionStruct[i].setval & test)
726        {
727          StringAppend(" %s",optionStruct[i].name);
728          tmp &=optionStruct[i].resetval;
729        }
730      }
731      for (i=0; i<32; i++)
732      {
733        if (tmp & Sy_bit(i)) StringAppend(" %d",i);
734      }
735    }
736    tmp=verbose;
737    if (tmp)
738    {
739      for (i=0; verboseStruct[i].setval!=0; i++)
740      {
741        if (verboseStruct[i].setval & tmp)
742        {
743          StringAppend(" %s",verboseStruct[i].name);
744          tmp &=verboseStruct[i].resetval;
745        }
746      }
747      for (i=1; i<32; i++)
748      {
749        if (tmp & Sy_bit(i)) StringAppend(" %d",i+32);
750      }
751    }
752    return omStrDup(StringAppendS(""));
753  }
754  else
755    return omStrDup(StringAppendS(" none"));
756}
757
758char * versionString()
759{
760  char* str = StringSetS("");
761  StringAppend("Singular for %s version %s (%d-%s)  %s\nwith\n",
762               S_UNAME, S_VERSION1, SINGULAR_VERSION,
763               feVersionId,singular_date);
764  StringAppendS("\t");
765#ifdef HAVE_FACTORY
766              StringAppend("factory(%s),", factoryVersion);
767              StringAppend("libfac(%s,%s),\n\t",libfac_version,libfac_date);
768#endif
769#if defined (__GNU_MP_VERSION) && defined (__GNU_MP_VERSION_MINOR)
770              StringAppend("GMP(%d.%d),",__GNU_MP_VERSION,__GNU_MP_VERSION_MINOR);
771#else
772              StringAppendS("GMP(1.3),");
773#endif
774#ifdef HAVE_NTL
775#include <NTL/version.h>
776              StringAppend("NTL(%s),",NTL_VERSION);
777#endif
778#ifdef HAVE_MPSR
779              StringAppend("MP(%s),",MP_VERSION);
780#endif
781#if SIZEOF_VOIDP == 8
782              StringAppendS("64bit,");
783#else
784              StringAppendS("32bit,");
785#endif
786#if defined(HAVE_DYN_RL)
787              if (fe_fgets_stdin==fe_fgets_dummy)
788                StringAppendS("no input,");
789              else if (fe_fgets_stdin==fe_fgets)
790                StringAppendS("fgets,");
791              if (fe_fgets_stdin==fe_fgets_stdin_drl)
792                StringAppendS("dynamic readline,");
793              #ifdef HAVE_FEREAD
794              else if (fe_fgets_stdin==fe_fgets_stdin_emu)
795                StringAppendS("emulated readline,");
796              #endif
797              else
798                StringAppendS("unknown fgets method,");
799#else
800  #if defined(HAVE_READLINE) && !defined(FEREAD)
801              StringAppendS("static readline,");
802  #else
803    #ifdef HAVE_FEREAD
804              StringAppendS("emulated readline,");
805    #else
806              StringAppendS("fgets,");
807    #endif
808  #endif
809#endif
810#ifdef HAVE_PLURAL
811              StringAppendS("Plural,");
812#endif
813#ifdef HAVE_DBM
814              StringAppendS("DBM,\n\t");
815#else
816              StringAppendS("\n\t");
817#endif
818#ifdef HAVE_DYNAMIC_LOADING
819              StringAppendS("dynamic modules,");
820#endif
821              if (p_procs_dynamic) StringAppendS("dynamic p_Procs,");
822#ifdef TEST
823              StringAppendS("TESTs,");
824#endif
825#if YYDEBUG
826              StringAppendS("YYDEBUG=1,");
827#endif
828#ifdef HAVE_ASSUME
829             StringAppendS("ASSUME,");
830#endif
831#ifdef MDEBUG
832              StringAppend("MDEBUG=%d,",MDEBUG);
833#endif
834#ifdef OM_CHECK
835              StringAppend("OM_CHECK=%d,",OM_CHECK);
836#endif
837#ifdef OM_TRACK
838              StringAppend("OM_TRACK=%d,",OM_TRACK);
839#endif
840#ifdef OM_NDEBUG
841              StringAppendS("OM_NDEBUG,");
842#endif
843#ifdef PDEBUG
844              StringAppendS("PDEBUG,");
845#endif
846#ifdef KDEBUG
847              StringAppendS("KDEBUG,");
848#endif
849#ifndef __OPTIMIZE__
850              StringAppendS("-g,");
851#endif
852#ifdef HAVE_EIGENVAL
853              StringAppendS("eigenvalues,");
854#endif
855#ifdef HAVE_GMS
856              StringAppendS("Gauss-Manin system,");
857#endif
858#ifdef HAVE_RATGRING
859              StringAppendS("ratGB,");
860#endif
861              StringAppend("random=%d\n",siRandomStart);
862              StringAppend("\tCC=%s,\n\tCXX=%s"
863#ifdef __GNUC__
864              "(" __VERSION__ ")"
865#endif
866              "\n",CC,CXX);
867              feStringAppendResources(0);
868              feStringAppendBrowsers(0);
869              StringAppendS("\n");
870              return str;
871}
872
873#ifdef PDEBUG
874#if (OM_TRACK > 2) && defined(OM_TRACK_CUSTOM)
875void p_SetRingOfLeftv(leftv l, ring r)
876{
877  switch(l->rtyp)
878  {
879    case INT_CMD:
880    case BIGINT_CMD:
881    case IDHDL:
882    case DEF_CMD:
883      break;
884    case POLY_CMD:
885    case VECTOR_CMD:
886    {
887      poly p=(poly)l->data;
888      while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
889      break;
890    }
891    case IDEAL_CMD:
892    case MODUL_CMD:
893    case MATRIX_CMD:
894    {
895      ideal I=(ideal)l->data;
896      int i;
897      for(i=IDELEMS(I)-1;i>=0;i--)
898      {
899        poly p=I->m[i];
900        while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
901      }
902      break;
903    }
904    case COMMAND:
905    {
906      command d=(command)l->data;
907      p_SetRingOfLeftv(&d->arg1, r);
908      if (d->argc>1) p_SetRingOfLeftv(&d->arg2, r);
909      if (d->argc>2) p_SetRingOfLeftv(&d->arg3, r);
910      break;
911    }
912    default:
913     printf("type %d not yet implementd in p_SetRingOfLeftv\n",l->rtyp);
914     break;
915  }
916}
917#endif
918#endif
919
920#if 0 /* debug only */
921void listall(int showproc)
922{
923      idhdl hh=basePack->idroot;
924      PrintS("====== Top ==============\n");
925      while (hh!=NULL)
926      {
927        if (showproc || (IDTYP(hh)!=PROC_CMD))
928        {
929          if (IDDATA(hh)==(void *)currRing) PrintS("(R)");
930          else if (IDDATA(hh)==(void *)currPack) PrintS("(P)");
931          else PrintS("   ");
932          Print("::%s, typ %s level %d data %lx",
933                 IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
934          if ((IDTYP(hh)==RING_CMD)
935          || (IDTYP(hh)==QRING_CMD))
936            Print(" ref: %d\n",IDRING(hh)->ref);
937          else
938            PrintLn();
939        }
940        hh=IDNEXT(hh);
941      }
942      hh=basePack->idroot;
943      while (hh!=NULL)
944      {
945        if (IDDATA(hh)==(void *)basePack)
946          Print("(T)::%s, typ %s level %d data %lx\n",
947          IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
948        else
949        if ((IDTYP(hh)==RING_CMD)
950        || (IDTYP(hh)==QRING_CMD)
951        || (IDTYP(hh)==PACKAGE_CMD))
952        {
953          Print("====== %s ==============\n",IDID(hh));
954          idhdl h2=IDRING(hh)->idroot;
955          while (h2!=NULL)
956          {
957            if (showproc || (IDTYP(h2)!=PROC_CMD))
958            {
959              if ((IDDATA(h2)==(void *)currRing)
960              && ((IDTYP(h2)==RING_CMD)||(IDTYP(h2)==QRING_CMD)))
961                PrintS("(R)");
962              else if (IDDATA(h2)==(void *)currPack) PrintS("(P)");
963              else PrintS("   ");
964              Print("%s::%s, typ %s level %d data %lx\n",
965              IDID(hh),IDID(h2),Tok2Cmdname(IDTYP(h2)),IDLEV(h2),(long)IDDATA(h2));
966            }
967            h2=IDNEXT(h2);
968          }
969        }
970        hh=IDNEXT(hh);
971      }
972      Print("currRing:%lx, currPack:%lx,basePack:%lx\n",(long)currRing,(long)currPack,(long)basePack);
973      iiCheckPack(currPack);
974}
975#endif
976
977#ifndef NDEBUG
978void checkall()
979{
980      idhdl hh=basePack->idroot;
981      while (hh!=NULL)
982      {
983        omCheckAddr(hh);
984        omCheckAddr((ADDRESS)IDID(hh));
985        if (RingDependend(IDTYP(hh))) Print("%s typ %d in Top\n",IDID(hh),IDTYP(hh));
986        hh=IDNEXT(hh);
987      }
988      hh=basePack->idroot;
989      while (hh!=NULL)
990      {
991        if (IDTYP(hh)==PACKAGE_CMD)
992        {
993          idhdl h2=IDPACKAGE(hh)->idroot;
994          while (h2!=NULL)
995          {
996            omCheckAddr(h2);
997            omCheckAddr((ADDRESS)IDID(h2));
998            if (RingDependend(IDTYP(h2))) Print("%s typ %d in %s\n",IDID(h2),IDTYP(h2),IDID(hh));
999            h2=IDNEXT(h2);
1000          }
1001        }
1002        hh=IDNEXT(hh);
1003      }
1004}
1005#endif
1006
1007#include <sys/types.h>
1008#include <sys/stat.h>
1009#include <unistd.h>
1010
1011extern "C"
1012int singular_fstat(int fd, struct stat *buf)
1013{
1014  return fstat(fd,buf);
1015}
1016
1017/*2
1018* the global exit routine of Singular
1019*/
1020#ifdef HAVE_MPSR
1021void (*MP_Exit_Env_Ptr)()=NULL;
1022#endif
1023
1024extern "C" {
1025
1026void m2_end(int i)
1027{
1028  fe_reset_input_mode();
1029  #ifdef PAGE_TEST
1030  mmEndStat();
1031  #endif
1032  fe_reset_input_mode();
1033  idhdl h = IDROOT;
1034  while(h != NULL)
1035  {
1036    if(IDTYP(h) == LINK_CMD)
1037    {
1038      idhdl hh=h->next;
1039      killhdl(h, currPack);
1040      h = hh;
1041    }
1042    else
1043    {
1044      h = h->next;
1045    }
1046  }
1047  if (i<=0)
1048  {
1049      if (TEST_V_QUIET)
1050      {
1051        if (i==0)
1052          printf("Auf Wiedersehen.\n");
1053        else
1054          printf("\n$Bye.\n");
1055      }
1056    //#ifdef sun
1057    //  #ifndef __svr4__
1058    //    _cleanup();
1059    //    _exit(0);
1060    //  #endif
1061    //#endif
1062    exit(0);
1063  }
1064  else
1065  {
1066      if(!singular_in_batchmode)
1067      {
1068        printf("\nhalt %d\n",i);
1069      }
1070  }
1071  #ifdef HAVE_MPSR
1072  if (MP_Exit_Env_Ptr!=NULL) (*MP_Exit_Env_Ptr)();
1073  #endif
1074  exit(i);
1075}
1076}
1077
1078const char *singular_date=__DATE__ " " __TIME__;
1079
1080int mmInit( void );
1081int mmIsInitialized=mmInit();
1082
1083extern "C"
1084{
1085  void omSingOutOfMemoryFunc()
1086  {
1087    fprintf(stderr, "\nSingular error: no more memory\n");
1088    omPrintStats(stderr);
1089    m2_end(14);
1090    /* should never get here */
1091    exit(1);
1092  }
1093}
1094
1095int mmInit( void )
1096{
1097  if(mmIsInitialized==0)
1098  {
1099
1100#ifndef LIBSINGULAR
1101#if defined(OMALLOC_USES_MALLOC) || defined(X_OMALLOC)
1102    /* in mmstd.c, for some architectures freeSize() unconditionally uses the *system* free() */
1103    /* sage ticket 5344: http://trac.sagemath.org/sage_trac/ticket/5344 */
1104#include <omalloc/omalloc.h>
1105    /* do not rely on the default in Singular as libsingular may be different */
1106    mp_set_memory_functions(omMallocFunc,omReallocSizeFunc,omFreeSizeFunc);
1107#else
1108    mp_set_memory_functions(malloc,reallocSize,freeSize);
1109#endif
1110#endif // ifndef LIBSINGULAR
1111    om_Opts.OutOfMemoryFunc = omSingOutOfMemoryFunc;
1112#ifndef OM_NDEBUG
1113#ifndef __OPTIMIZE__
1114    om_Opts.ErrorHook = dErrorBreak;
1115#endif
1116#endif
1117    omInitInfo();
1118#ifdef OM_SING_KEEP
1119    om_Opts.Keep = OM_SING_KEEP;
1120#endif
1121  }
1122  mmIsInitialized=1;
1123  return 1;
1124}
1125
1126int siInit(char *name)
1127{
1128#ifdef HAVE_FACTORY
1129  On(SW_USE_NTL);
1130  Off(SW_USE_GCD_P);
1131  On(SW_USE_NTL_GCD_0); // On -> seg11 in Old/algnorm, Old/factor...
1132  On(SW_USE_NTL_GCD_P); // On -> cyle in Short/brnoeth_s: fixed
1133  On(SW_USE_EZGCD);
1134  On(SW_USE_CHINREM_GCD);
1135  //On(SW_USE_FF_MOD_GCD);
1136  //On(SW_USE_fieldGCD);
1137  On(SW_USE_EZGCD_P);
1138  On(SW_USE_QGCD);
1139  Off(SW_USE_NTL_SORT); // may be changed by an command line option
1140#endif
1141
1142#ifdef INIT_BUG
1143  jjInitTab1();
1144#endif
1145  /* initialize components */
1146  factoryError=WerrorS;
1147  siRandomStart=inits();
1148  feOptSpec[FE_OPT_RANDOM].value = (void*) ((long)siRandomStart);
1149
1150  // Don't worry: ifdef OM_NDEBUG, then all these calls are undef'ed
1151  // hack such that all shared' libs in the bindir are loaded correctly
1152  feInitResources(name);
1153  extern int iiInitArithmetic();
1154  iiInitArithmetic();
1155
1156  basePack=(package)omAlloc0(sizeof(*basePack));
1157  currPack=basePack;
1158  idhdl h;
1159  h=enterid("Top", 0, PACKAGE_CMD, &IDROOT, TRUE);
1160  IDPACKAGE(h)->language = LANG_TOP;
1161  IDPACKAGE(h)=basePack;
1162  currPackHdl=h;
1163  basePackHdl=h;
1164
1165  slStandardInit();
1166  myynest=0;
1167
1168  if (! feOptValue(FE_OPT_NO_STDLIB))
1169  {
1170    int vv=verbose;
1171    verbose &= ~Sy_bit(V_LOAD_LIB);
1172    iiLibCmd(omStrDup("standard.lib"), TRUE,TRUE,TRUE);
1173    verbose=vv;
1174  }
1175  errorreported = 0;
1176}
1177
Note: See TracBrowser for help on using the repository browser.