source: git/Singular/misc_ip.cc @ d19fa2

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