source: git/Singular/misc_ip.cc @ ae816e

fieker-DuValspielwiese
Last change on this file since ae816e was 81845eb, checked in by Oleksandr Motsak <motsak@…>, 12 years ago
final adaptation to libfac merged into factory FIX: no libfac_* vars + correct include: factory/libfac/factor.h
  • 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 misc_ip.h.
9 *
10 * @internal @version \$Id$
11 *
12 **/
13/*****************************************************************************/
14
15// include header files
16#include <misc/auxiliary.h>
17#include <kernel/mod2.h>
18
19#ifdef HAVE_FACTORY
20#define SI_DONT_HAVE_GLOBAL_VARS
21#include <factory/factory.h>
22#endif
23
24#include <coeffs/si_gmp.h>
25#include <coeffs/coeffs.h>
26
27#include <polys/ext_fields/algext.h>
28#include <polys/ext_fields/transext.h>
29
30#include "misc_ip.h"
31#include "ipid.h"
32#include "feOpt.h"
33#include "silink.h"
34
35// the following 2 inline functions are just convenience shortcuts for Frank's code:
36static inline void number2mpz(number n, mpz_t m){ n_MPZ(m, n, coeffs_BIGINT); }
37static inline number mpz2number(mpz_t m){ return n_Init(m, coeffs_BIGINT); }
38
39
40void divTimes(mpz_t n, mpz_t d, int* times)
41{
42  *times = 0;
43  mpz_t r; mpz_init(r);
44  mpz_t q; mpz_init(q);
45  mpz_fdiv_qr(q, r, n, d);
46  while (mpz_cmp_ui(r, 0) == 0)
47  {
48    (*times)++;
49    mpz_set(n, q);
50    mpz_fdiv_qr(q, r, n, d);
51  }
52  mpz_clear(r);
53  mpz_clear(q);
54}
55
56void divTimes_ui(mpz_t n, unsigned long d, int* times)
57{
58  *times = 0;
59  mpz_t r; mpz_init(r);
60  mpz_t q; mpz_init(q);
61  mpz_fdiv_qr_ui(q, r, n, d);
62  while (mpz_cmp_ui(r, 0) == 0)
63  {
64    (*times)++;
65    mpz_set(n, q);
66    mpz_fdiv_qr_ui(q, r, n, d);
67  }
68  mpz_clear(r);
69  mpz_clear(q);
70}
71
72static inline void divTimes_ui_ui(unsigned long *n, unsigned long d, int* times)
73{
74  *times = 0;
75  unsigned long q=(*n) / d;
76  unsigned long r=(*n) % d;
77  while (r==0)
78  {
79    (*times)++;
80    (*n)=q;
81    q=(*n)/d; r=(*n)%d;
82  }
83}
84
85void setListEntry(lists L, int index, mpz_t n)
86{ /* assumes n > 0 */
87  /* try to fit nn into an int: */
88  if (mpz_size1(n)<=1)
89  {
90    int ui=(int)mpz_get_si(n);
91    if ((((ui<<3)>>3)==ui)
92    && (mpz_cmp_si(n,(long)ui)==0))
93    {
94      L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)ui;
95      return;
96    }
97  }
98  number nn = mpz2number(n);
99  L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
100}
101
102void setListEntry_ui(lists L, int index, unsigned long ui)
103{ /* assumes n > 0 */
104  /* try to fit nn into an int: */
105  int i=(int)ui;
106  if ((((unsigned long)i)==ui) && (((i<<3)>>3)==i))
107  {
108    L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)i;
109  }
110  else
111  {
112    number nn = n_Init(ui, coeffs_BIGINT);
113    L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
114  }
115}
116
117/* true iff p is prime */
118/*
119bool isPrime(mpz_t p)
120{
121  if (mpz_cmp_ui(p, 2) == 0) return true;
122  if (mpz_cmp_ui(p, 3) == 0) return true;
123  if (mpz_cmp_ui(p, 5) < 0)  return false;
124
125  mpz_t d; mpz_init_set_ui(d, 5); int add = 2;
126  mpz_t sr; mpz_init(sr); mpz_sqrt(sr, p);
127  mpz_t r; mpz_init(r);
128  while (mpz_cmp(d, sr) <= 0)
129  {
130    mpz_cdiv_r(r, p, d);
131    if (mpz_cmp_ui(r, 0) == 0)
132    {
133      mpz_clear(d); mpz_clear(sr); mpz_clear(r);
134      return false;
135    }
136    mpz_add_ui(d, d, add);
137    add += 2; if (add == 6) add = 2;
138  }
139  mpz_clear(d); mpz_clear(sr); mpz_clear(r);
140  return true;
141}
142*/
143
144/* finds the next prime q, bound >= q >= p;
145   in case of success, puts q into p;
146   otherwise sets q = bound + 1;
147   e.g. p = 24; nextPrime(p, 30) produces p = 29 (success),
148        p = 24; nextPrime(p, 29) produces p = 29 (success),
149        p = 24; nextPrime(p, 28) produces p = 29 (no success),
150        p = 24; nextPrime(p, 27) produces p = 28 (no success) */
151/*
152void nextPrime(mpz_t p, mpz_t bound)
153{
154  int add;
155  mpz_t r; mpz_init(r); mpz_cdiv_r_ui(r, p, 6); // r = p mod 6, 0 <= r <= 5
156  if (mpz_cmp_ui(r, 0) == 0) { mpz_add_ui(p, p, 1); add = 4; }
157  if (mpz_cmp_ui(r, 1) == 0) {                      add = 4; }
158  if (mpz_cmp_ui(r, 2) == 0) { mpz_add_ui(p, p, 3); add = 2; }
159  if (mpz_cmp_ui(r, 3) == 0) { mpz_add_ui(p, p, 2); add = 2; }
160  if (mpz_cmp_ui(r, 4) == 0) { mpz_add_ui(p, p, 1); add = 2; }
161  if (mpz_cmp_ui(r, 5) == 0) {                      add = 2; }
162
163  while (mpz_cmp(p, bound) <= 0)
164  {
165    if (isPrime(p)) { mpz_clear(r); return; }
166    mpz_add_ui(p, p, add);
167    add += 2; if (add == 6) add = 2;
168  }
169  mpz_set(p, bound);
170  mpz_add_ui(p, p, 1);
171  mpz_clear(r);
172  return;
173}
174*/
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 (!n_IsZero(n, coeffs_BIGINT))
191  {
192    if (!n_GreaterZero(n, coeffs_BIGINT))
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 <omalloc/omalloc.h>
335#include <misc/mylimits.h>
336
337#include <misc/options.h>
338#include <misc/intvec.h>
339
340#include <polys/monomials/ring.h>
341#include <polys/templates/p_Procs.h>
342
343#include <kernel/febase.h>
344#include <kernel/page.h>
345#include <kernel/kstd1.h>
346#include <kernel/timer.h>
347
348
349#include "subexpr.h"
350#include "cntrlc.h"
351#include "ipid.h"
352#include "ipshell.h"
353
354#include "version.h"
355#include "static.h"
356
357#include "fehelp.h"
358
359#ifdef HAVE_STATIC
360#undef HAVE_DYN_RL
361#endif
362
363#define SI_DONT_HAVE_GLOBAL_VARS
364
365//#ifdef HAVE_LIBPARSER
366//#  include "libparse.h"
367//#endif /* HAVE_LIBPARSER */
368
369
370/* version strings */
371#ifdef HAVE_MPSR
372#include <MP_Config.h>
373#endif
374
375/*2
376* the renice routine for very large jobs
377* works only on unix machines,
378* testet on : linux, HP 9.0
379*
380*#include <sys/times.h>
381*#include <sys/resource.h>
382*extern "C" int setpriority(int,int,int);
383*void very_nice()
384*{
385*#ifndef NO_SETPRIORITY
386*  setpriority(PRIO_PROCESS,0,19);
387*#endif
388*  sleep(10);
389*}
390*/
391
392#include <string.h>
393#include <unistd.h>
394#include <stdio.h>
395#include <stddef.h>
396#include <stdlib.h>
397#include <time.h>
398
399
400void singular_example(char *str)
401{
402  assume(str!=NULL);
403  char *s=str;
404  while (*s==' ') s++;
405  char *ss=s;
406  while (*ss!='\0') ss++;
407  while (*ss<=' ')
408  {
409    *ss='\0';
410    ss--;
411  }
412  idhdl h=IDROOT->get(s,myynest);
413  if ((h!=NULL) && (IDTYP(h)==PROC_CMD))
414  {
415    char *lib=iiGetLibName(IDPROC(h));
416    if((lib!=NULL)&&(*lib!='\0'))
417    {
418      Print("// proc %s from lib %s\n",s,lib);
419      s=iiGetLibProcBuffer(IDPROC(h), 2);
420      if (s!=NULL)
421      {
422        if (strlen(s)>5)
423        {
424          iiEStart(s,IDPROC(h));
425          omFree((ADDRESS)s);
426          return;
427        }
428        else omFree((ADDRESS)s);
429      }
430    }
431  }
432  else
433  {
434    char sing_file[MAXPATHLEN];
435    FILE *fd=NULL;
436    char *res_m=feResource('m', 0);
437    if (res_m!=NULL)
438    {
439      sprintf(sing_file, "%s/%s.sing", res_m, s);
440      fd = feFopen(sing_file, "r");
441    }
442    if (fd != NULL)
443    {
444
445      int old_echo = si_echo;
446      int length, got;
447      char* s;
448
449      fseek(fd, 0, SEEK_END);
450      length = ftell(fd);
451      fseek(fd, 0, SEEK_SET);
452      s = (char*) omAlloc((length+20)*sizeof(char));
453      got = fread(s, sizeof(char), length, fd);
454      fclose(fd);
455      if (got != length)
456      {
457        Werror("Error while reading file %s", sing_file);
458      }
459      else
460      {
461        s[length] = '\0';
462        strcat(s, "\n;return();\n\n");
463        si_echo = 2;
464        iiEStart(s, NULL);
465        si_echo = old_echo;
466      }
467      omFree(s);
468    }
469    else
470    {
471      Werror("no example for %s", str);
472    }
473  }
474}
475
476
477struct soptionStruct
478{
479  const char * name;
480  unsigned   setval;
481  unsigned   resetval;
482};
483
484struct soptionStruct optionStruct[]=
485{
486  {"prot",         Sy_bit(OPT_PROT),           ~Sy_bit(OPT_PROT)   },
487  {"redSB",        Sy_bit(OPT_REDSB),          ~Sy_bit(OPT_REDSB)   },
488  {"notBuckets",   Sy_bit(OPT_NOT_BUCKETS),    ~Sy_bit(OPT_NOT_BUCKETS)   },
489  {"notSugar",     Sy_bit(OPT_NOT_SUGAR),      ~Sy_bit(OPT_NOT_SUGAR)   },
490  {"interrupt",    Sy_bit(OPT_INTERRUPT),      ~Sy_bit(OPT_INTERRUPT)   },
491  {"sugarCrit",    Sy_bit(OPT_SUGARCRIT),      ~Sy_bit(OPT_SUGARCRIT)   },
492  {"teach",        Sy_bit(OPT_DEBUG),          ~Sy_bit(OPT_DEBUG)  },
493  {"notSyzMinim",  Sy_bit(OPT_NO_SYZ_MINIM),   ~Sy_bit(OPT_NO_SYZ_MINIM)  },
494  /* 9 return SB in syz, quotient, intersect */
495  {"returnSB",     Sy_bit(OPT_RETURN_SB),      ~Sy_bit(OPT_RETURN_SB)  },
496  {"fastHC",       Sy_bit(OPT_FASTHC),         ~Sy_bit(OPT_FASTHC)  },
497  /* 11-19 sort in L/T */
498  {"staircaseBound",Sy_bit(OPT_STAIRCASEBOUND),~Sy_bit(OPT_STAIRCASEBOUND)  },
499  {"multBound",    Sy_bit(OPT_MULTBOUND),      ~Sy_bit(OPT_MULTBOUND)  },
500  {"degBound",     Sy_bit(OPT_DEGBOUND),       ~Sy_bit(OPT_DEGBOUND)  },
501  /* 25 no redTail(p)/redTail(s) */
502  {"redTail",      Sy_bit(OPT_REDTAIL),        ~Sy_bit(OPT_REDTAIL)  },
503  {"redThrough",   Sy_bit(OPT_REDTHROUGH),     ~Sy_bit(OPT_REDTHROUGH)  },
504  {"lazy",         Sy_bit(OPT_OLDSTD),         ~Sy_bit(OPT_OLDSTD)  },
505  {"intStrategy",  Sy_bit(OPT_INTSTRATEGY),    ~Sy_bit(OPT_INTSTRATEGY)  },
506  {"infRedTail",   Sy_bit(OPT_INFREDTAIL),     ~Sy_bit(OPT_INFREDTAIL)  },
507  /* 30: use not regularity for syz */
508  {"notRegularity",Sy_bit(OPT_NOTREGULARITY),  ~Sy_bit(OPT_NOTREGULARITY)  },
509  {"weightM",      Sy_bit(OPT_WEIGHTM),        ~Sy_bit(OPT_WEIGHTM)  },
510/*special for "none" and also end marker for showOption:*/
511  {"ne",           0,                          0 }
512};
513
514struct soptionStruct verboseStruct[]=
515{
516  {"mem",      Sy_bit(V_SHOW_MEM),  ~Sy_bit(V_SHOW_MEM)   },
517  {"yacc",     Sy_bit(V_YACC),      ~Sy_bit(V_YACC)       },
518  {"redefine", Sy_bit(V_REDEFINE),  ~Sy_bit(V_REDEFINE)   },
519  {"reading",  Sy_bit(V_READING),   ~Sy_bit(V_READING)    },
520  {"loadLib",  Sy_bit(V_LOAD_LIB),  ~Sy_bit(V_LOAD_LIB)   },
521  {"debugLib", Sy_bit(V_DEBUG_LIB), ~Sy_bit(V_DEBUG_LIB)  },
522  {"loadProc", Sy_bit(V_LOAD_PROC), ~Sy_bit(V_LOAD_PROC)  },
523  {"defRes",   Sy_bit(V_DEF_RES),   ~Sy_bit(V_DEF_RES)    },
524  {"usage",    Sy_bit(V_SHOW_USE),  ~Sy_bit(V_SHOW_USE)   },
525  {"Imap",     Sy_bit(V_IMAP),      ~Sy_bit(V_IMAP)       },
526  {"prompt",   Sy_bit(V_PROMPT),    ~Sy_bit(V_PROMPT)     },
527  {"length",   Sy_bit(V_LENGTH),    ~Sy_bit(V_LENGTH)     },
528  {"notWarnSB",Sy_bit(V_NSB),       ~Sy_bit(V_NSB)        },
529  {"contentSB",Sy_bit(V_CONTENTSB), ~Sy_bit(V_CONTENTSB)  },
530  {"cancelunit",Sy_bit(V_CANCELUNIT),~Sy_bit(V_CANCELUNIT)},
531  {"modpsolve",Sy_bit(V_MODPSOLVSB),~Sy_bit(V_MODPSOLVSB)},
532  {"geometricSB",Sy_bit(V_UPTORADICAL),~Sy_bit(V_UPTORADICAL)},
533  {"findMonomials",Sy_bit(V_FINDMONOM),~Sy_bit(V_FINDMONOM)},
534  {"coefStrat",Sy_bit(V_COEFSTRAT), ~Sy_bit(V_COEFSTRAT)},
535  {"qringNF",  Sy_bit(V_QRING),     ~Sy_bit(V_QRING)},
536  {"warn",     Sy_bit(V_ALLWARN),   ~Sy_bit(V_ALLWARN)},
537  {"interedSyz",Sy_bit(V_INTERSECT_SYZ), ~Sy_bit(V_INTERSECT_SYZ)},
538  {"interedElim",Sy_bit(V_INTERSECT_ELIM), ~Sy_bit(V_INTERSECT_ELIM)},
539/*special for "none" and also end marker for showOption:*/
540  {"ne",         0,          0 }
541};
542
543BOOLEAN setOption(leftv res, leftv v)
544{
545  const char *n;
546  do
547  {
548    if (v->Typ()==STRING_CMD)
549    {
550      n=(const char *)v->CopyD(STRING_CMD);
551    }
552    else
553    {
554      if (v->name==NULL)
555        return TRUE;
556      if (v->rtyp==0)
557      {
558        n=v->name;
559        v->name=NULL;
560      }
561      else
562      {
563        n=omStrDup(v->name);
564      }
565    }
566
567    int i;
568
569    if(strcmp(n,"get")==0)
570    {
571      intvec *w=new intvec(2);
572      (*w)[0]=test;
573      (*w)[1]=verbose;
574      res->rtyp=INTVEC_CMD;
575      res->data=(void *)w;
576      goto okay;
577    }
578    if(strcmp(n,"set")==0)
579    {
580      if((v->next!=NULL)
581      &&(v->next->Typ()==INTVEC_CMD))
582      {
583        v=v->next;
584        intvec *w=(intvec*)v->Data();
585        test=(*w)[0];
586        verbose=(*w)[1];
587#if 0
588        if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
589        && rField_has_simple_inverse()
590#ifdef HAVE_RINGS
591        && !rField_is_Ring(currRing)
592#endif
593        ) {
594          test &=~Sy_bit(OPT_INTSTRATEGY);
595        }
596#endif
597        goto okay;
598      }
599    }
600    if(strcmp(n,"none")==0)
601    {
602      test=0;
603      verbose=0;
604      goto okay;
605    }
606    for (i=0; (i==0) || (optionStruct[i-1].setval!=0); i++)
607    {
608      if (strcmp(n,optionStruct[i].name)==0)
609      {
610        if (optionStruct[i].setval & validOpts)
611        {
612          test |= optionStruct[i].setval;
613          // optOldStd disables redthrough
614          if (optionStruct[i].setval == Sy_bit(OPT_OLDSTD))
615            test &= ~Sy_bit(OPT_REDTHROUGH);
616        }
617        else
618          Warn("cannot set option");
619#if 0
620        if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
621        && rField_has_simple_inverse()
622#ifdef HAVE_RINGS
623        && !rField_is_Ring(currRing)
624#endif
625        ) {
626          test &=~Sy_bit(OPT_INTSTRATEGY);
627        }
628#endif
629        goto okay;
630      }
631      else if ((strncmp(n,"no",2)==0)
632      && (strcmp(n+2,optionStruct[i].name)==0))
633      {
634        if (optionStruct[i].setval & validOpts)
635        {
636          test &= optionStruct[i].resetval;
637        }
638        else
639          Warn("cannot clear option");
640        goto okay;
641      }
642    }
643    for (i=0; (i==0) || (verboseStruct[i-1].setval!=0); i++)
644    {
645      if (strcmp(n,verboseStruct[i].name)==0)
646      {
647        verbose |= verboseStruct[i].setval;
648        #ifdef YYDEBUG
649        #if YYDEBUG
650        /*debugging the bison grammar --> grammar.cc*/
651        extern int    yydebug;
652        if (BVERBOSE(V_YACC)) yydebug=1;
653        else                  yydebug=0;
654        #endif
655        #endif
656        goto okay;
657      }
658      else if ((strncmp(n,"no",2)==0)
659      && (strcmp(n+2,verboseStruct[i].name)==0))
660      {
661        verbose &= verboseStruct[i].resetval;
662        #ifdef YYDEBUG
663        #if YYDEBUG
664        /*debugging the bison grammar --> grammar.cc*/
665        extern int    yydebug;
666        if (BVERBOSE(V_YACC)) yydebug=1;
667        else                  yydebug=0;
668        #endif
669        #endif
670        goto okay;
671      }
672    }
673    Werror("unknown option `%s`",n);
674  okay:
675    if (currRing != NULL)
676      currRing->options = test & TEST_RINGDEP_OPTS;
677    omFree((ADDRESS)n);
678    v=v->next;
679  } while (v!=NULL);
680   
681#ifdef OM_SINGULAR_CONFIG_H
682   // set global variable to show memory usage
683  extern int om_sing_opt_show_mem;
684  if (BVERBOSE(V_SHOW_MEM)) om_sing_opt_show_mem = 1;
685  else om_sing_opt_show_mem = 0;
686#endif
687   
688  return FALSE;
689}
690
691char * showOption()
692{
693  int i;
694  BITSET tmp;
695
696  StringSetS("//options:");
697  if ((test!=0)||(verbose!=0))
698  {
699    tmp=test;
700    if(tmp)
701    {
702      for (i=0; optionStruct[i].setval!=0; i++)
703      {
704        if (optionStruct[i].setval & test)
705        {
706          StringAppend(" %s",optionStruct[i].name);
707          tmp &=optionStruct[i].resetval;
708        }
709      }
710      for (i=0; i<32; i++)
711      {
712        if (tmp & Sy_bit(i)) StringAppend(" %d",i);
713      }
714    }
715    tmp=verbose;
716    if (tmp)
717    {
718      for (i=0; verboseStruct[i].setval!=0; i++)
719      {
720        if (verboseStruct[i].setval & tmp)
721        {
722          StringAppend(" %s",verboseStruct[i].name);
723          tmp &=verboseStruct[i].resetval;
724        }
725      }
726      for (i=1; i<32; i++)
727      {
728        if (tmp & Sy_bit(i)) StringAppend(" %d",i+32);
729      }
730    }
731    return omStrDup(StringAppendS(""));
732  }
733  else
734    return omStrDup(StringAppendS(" none"));
735}
736
737char * versionString()
738{
739  char* str = StringSetS("");
740  StringAppend("Singular for %s version %s (%d-%s)  %s\nwith\n",
741               S_UNAME, S_VERSION1, SINGULAR_VERSION,
742               feVersionId,singular_date);
743  StringAppendS("\t");
744#ifdef HAVE_FACTORY
745  StringAppend("factory(%s)", factoryVersion);
746#ifdef HAVE_LIBFAC
747  // libfac:
748//  extern const char * libfac_version;
749//  extern const char * libfac_date;
750  StringAppend("+libfac");
751#endif // #ifdef HAVE_LIBFAC
752  StringAppend(",");
753#endif
754
755#if defined (__GNU_MP_VERSION) && defined (__GNU_MP_VERSION_MINOR)
756              StringAppend("GMP(%d.%d),",__GNU_MP_VERSION,__GNU_MP_VERSION_MINOR);
757#else
758              StringAppendS("GMP(1.3),");
759#endif
760#ifdef HAVE_NTL
761#include <NTL/version.h>
762              StringAppend("NTL(%s),",NTL_VERSION);
763#endif
764#ifdef HAVE_MPSR
765              StringAppend("MP(%s),",MP_VERSION);
766#endif
767#if SIZEOF_VOIDP == 8
768              StringAppendS("64bit,");
769#else
770              StringAppendS("32bit,");
771#endif
772#if defined(HAVE_DYN_RL)
773              if (fe_fgets_stdin==fe_fgets_dummy)
774                StringAppendS("no input,");
775              else if (fe_fgets_stdin==fe_fgets)
776                StringAppendS("fgets,");
777              if (fe_fgets_stdin==fe_fgets_stdin_drl)
778                StringAppendS("dynamic readline,");
779              #ifdef HAVE_FEREAD
780              else if (fe_fgets_stdin==fe_fgets_stdin_emu)
781                StringAppendS("emulated readline,");
782              #endif
783              else
784                StringAppendS("unknown fgets method,");
785#else
786  #if defined(HAVE_READLINE) && !defined(FEREAD)
787              StringAppendS("static readline,");
788  #else
789    #ifdef HAVE_FEREAD
790              StringAppendS("emulated readline,");
791    #else
792              StringAppendS("fgets,");
793    #endif
794  #endif
795#endif
796#ifdef HAVE_PLURAL
797              StringAppendS("Plural,");
798#endif
799#ifdef HAVE_DBM
800              StringAppendS("DBM,\n\t");
801#else
802              StringAppendS("\n\t");
803#endif
804#ifdef HAVE_DYNAMIC_LOADING
805              StringAppendS("dynamic modules,");
806#endif
807              if (p_procs_dynamic) StringAppendS("dynamic p_Procs,");
808#ifdef TEST
809              StringAppendS("TESTs,");
810#endif
811#if YYDEBUG
812              StringAppendS("YYDEBUG=1,");
813#endif
814#ifdef HAVE_ASSUME
815             StringAppendS("ASSUME,");
816#endif
817#ifdef MDEBUG
818              StringAppend("MDEBUG=%d,",MDEBUG);
819#endif
820#ifdef OM_CHECK
821              StringAppend("OM_CHECK=%d,",OM_CHECK);
822#endif
823#ifdef OM_TRACK
824              StringAppend("OM_TRACK=%d,",OM_TRACK);
825#endif
826#ifdef OM_NDEBUG
827              StringAppendS("OM_NDEBUG,");
828#endif
829#ifdef PDEBUG
830              StringAppendS("PDEBUG,");
831#endif
832#ifdef KDEBUG
833              StringAppendS("KDEBUG,");
834#endif
835#ifndef __OPTIMIZE__
836              StringAppendS("-g,");
837#endif
838#ifdef HAVE_EIGENVAL
839              StringAppendS("eigenvalues,");
840#endif
841#ifdef HAVE_GMS
842              StringAppendS("Gauss-Manin system,");
843#endif
844#ifdef HAVE_RATGRING
845              StringAppendS("ratGB,");
846#endif
847              StringAppend("random=%d\n",siRandomStart);
848              StringAppend("\tCC=%s,\n\tCXX=%s"
849#ifdef __GNUC__
850              "(" __VERSION__ ")"
851#endif
852              "\n",CC,CXX);
853              feStringAppendResources(0);
854              feStringAppendBrowsers(0);
855              StringAppendS("\n");
856              return str;
857}
858
859#ifdef PDEBUG
860#if (OM_TRACK > 2) && defined(OM_TRACK_CUSTOM)
861void p_SetRingOfLeftv(leftv l, ring r)
862{
863  switch(l->rtyp)
864  {
865    case INT_CMD:
866    case BIGINT_CMD:
867    case IDHDL:
868    case DEF_CMD:
869      break;
870    case POLY_CMD:
871    case VECTOR_CMD:
872    {
873      poly p=(poly)l->data;
874      while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
875      break;
876    }
877    case IDEAL_CMD:
878    case MODUL_CMD:
879    case MATRIX_CMD:
880    {
881      ideal I=(ideal)l->data;
882      int i;
883      for(i=IDELEMS(I)-1;i>=0;i--)
884      {
885        poly p=I->m[i];
886        while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
887      }
888      break;
889    }
890    case COMMAND:
891    {
892      command d=(command)l->data;
893      p_SetRingOfLeftv(&d->arg1, r);
894      if (d->argc>1) p_SetRingOfLeftv(&d->arg2, r);
895      if (d->argc>2) p_SetRingOfLeftv(&d->arg3, r);
896      break;
897    }
898    default:
899     printf("type %d not yet implementd in p_SetRingOfLeftv\n",l->rtyp);
900     break;
901  }
902}
903#endif
904#endif
905
906#if 0 /* debug only */
907void listall(int showproc)
908{
909      idhdl hh=basePack->idroot;
910      PrintS("====== Top ==============\n");
911      while (hh!=NULL)
912      {
913        if (showproc || (IDTYP(hh)!=PROC_CMD))
914        {
915          if (IDDATA(hh)==(void *)currRing) PrintS("(R)");
916          else if (IDDATA(hh)==(void *)currPack) PrintS("(P)");
917          else PrintS("   ");
918          Print("::%s, typ %s level %d data %lx",
919                 IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
920          if ((IDTYP(hh)==RING_CMD)
921          || (IDTYP(hh)==QRING_CMD))
922            Print(" ref: %d\n",IDRING(hh)->ref);
923          else
924            PrintLn();
925        }
926        hh=IDNEXT(hh);
927      }
928      hh=basePack->idroot;
929      while (hh!=NULL)
930      {
931        if (IDDATA(hh)==(void *)basePack)
932          Print("(T)::%s, typ %s level %d data %lx\n",
933          IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
934        else
935        if ((IDTYP(hh)==RING_CMD)
936        || (IDTYP(hh)==QRING_CMD)
937        || (IDTYP(hh)==PACKAGE_CMD))
938        {
939          Print("====== %s ==============\n",IDID(hh));
940          idhdl h2=IDRING(hh)->idroot;
941          while (h2!=NULL)
942          {
943            if (showproc || (IDTYP(h2)!=PROC_CMD))
944            {
945              if ((IDDATA(h2)==(void *)currRing)
946              && ((IDTYP(h2)==RING_CMD)||(IDTYP(h2)==QRING_CMD)))
947                PrintS("(R)");
948              else if (IDDATA(h2)==(void *)currPack) PrintS("(P)");
949              else PrintS("   ");
950              Print("%s::%s, typ %s level %d data %lx\n",
951              IDID(hh),IDID(h2),Tok2Cmdname(IDTYP(h2)),IDLEV(h2),(long)IDDATA(h2));
952            }
953            h2=IDNEXT(h2);
954          }
955        }
956        hh=IDNEXT(hh);
957      }
958      Print("currRing:%lx, currPack:%lx,basePack:%lx\n",(long)currRing,(long)currPack,(long)basePack);
959      iiCheckPack(currPack);
960}
961#endif
962
963#ifndef NDEBUG
964void checkall()
965{
966      idhdl hh=basePack->idroot;
967      while (hh!=NULL)
968      {
969        omCheckAddr(hh);
970        omCheckAddr((ADDRESS)IDID(hh));
971        if (RingDependend(IDTYP(hh))) Print("%s typ %d in Top\n",IDID(hh),IDTYP(hh));
972        hh=IDNEXT(hh);
973      }
974      hh=basePack->idroot;
975      while (hh!=NULL)
976      {
977        if (IDTYP(hh)==PACKAGE_CMD)
978        {
979          idhdl h2=IDPACKAGE(hh)->idroot;
980          while (h2!=NULL)
981          {
982            omCheckAddr(h2);
983            omCheckAddr((ADDRESS)IDID(h2));
984            if (RingDependend(IDTYP(h2))) Print("%s typ %d in %s\n",IDID(h2),IDTYP(h2),IDID(hh));
985            h2=IDNEXT(h2);
986          }
987        }
988        hh=IDNEXT(hh);
989      }
990}
991#endif
992
993#include <sys/types.h>
994#include <sys/stat.h>
995#include <unistd.h>
996
997extern "C"
998int singular_fstat(int fd, struct stat *buf)
999{
1000  return fstat(fd,buf);
1001}
1002
1003/*2
1004* the global exit routine of Singular
1005*/
1006#ifdef HAVE_MPSR
1007void (*MP_Exit_Env_Ptr)()=NULL;
1008#endif
1009
1010extern "C" {
1011
1012void m2_end(int i)
1013{
1014  fe_reset_input_mode();
1015  #ifdef PAGE_TEST
1016  mmEndStat();
1017  #endif
1018  fe_reset_input_mode();
1019  idhdl h = IDROOT;
1020  while(h != NULL)
1021  {
1022    if(IDTYP(h) == LINK_CMD)
1023    {
1024      idhdl hh=h->next;
1025      killhdl(h, currPack);
1026      h = hh;
1027    }
1028    else
1029    {
1030      h = h->next;
1031    }
1032  }
1033  if (i<=0)
1034  {
1035      if (TEST_V_QUIET)
1036      {
1037        if (i==0)
1038          printf("Auf Wiedersehen.\n");
1039        else
1040          printf("\n$Bye.\n");
1041      }
1042    //#ifdef sun
1043    //  #ifndef __svr4__
1044    //    _cleanup();
1045    //    _exit(0);
1046    //  #endif
1047    //#endif
1048    exit(0);
1049  }
1050  else
1051  {
1052      if(!singular_in_batchmode)
1053      {
1054        printf("\nhalt %d\n",i);
1055      }
1056  }
1057  #ifdef HAVE_MPSR
1058  if (MP_Exit_Env_Ptr!=NULL) (*MP_Exit_Env_Ptr)();
1059  #endif
1060  exit(i);
1061}
1062}
1063
1064const char *singular_date=__DATE__ " " __TIME__;
1065
1066extern "C"
1067{
1068  void omSingOutOfMemoryFunc()
1069  {
1070    fprintf(stderr, "\nSingular error: no more memory\n");
1071    omPrintStats(stderr);
1072    m2_end(14);
1073    /* should never get here */
1074    exit(1);
1075  }
1076}
1077
1078/*2
1079* initialize components of Singular
1080*/
1081void siInit(char *name)
1082{
1083#ifdef HAVE_FACTORY
1084// factory default settings: -----------------------------------------------
1085  On(SW_USE_NTL);
1086  On(SW_USE_NTL_GCD_0); // On -> seg11 in Old/algnorm, Old/factor...
1087  On(SW_USE_NTL_GCD_P); // On -> cyle in Short/brnoeth_s: fixed
1088  On(SW_USE_EZGCD);
1089  On(SW_USE_CHINREM_GCD);
1090  //On(SW_USE_FF_MOD_GCD);
1091  //On(SW_USE_fieldGCD);
1092  On(SW_USE_EZGCD_P);
1093  On(SW_USE_QGCD);
1094  Off(SW_USE_NTL_SORT); // may be changed by an command line option
1095  factoryError=WerrorS;
1096#endif
1097
1098// memory initialization: -----------------------------------------------
1099    om_Opts.OutOfMemoryFunc = omSingOutOfMemoryFunc;
1100#ifndef OM_NDEBUG
1101#ifndef __OPTIMIZE__
1102    om_Opts.ErrorHook = dErrorBreak;
1103#endif
1104#endif
1105    omInitInfo();
1106#ifdef OM_SING_KEEP
1107    om_Opts.Keep = OM_SING_KEEP;
1108#endif
1109
1110// interpreter tables etc.: -----------------------------------------------
1111#ifdef INIT_BUG
1112  jjInitTab1();
1113#endif
1114  memset(&sLastPrinted,0,sizeof(sleftv));
1115  sLastPrinted.rtyp=NONE;
1116 
1117  extern int iiInitArithmetic(); iiInitArithmetic(); // iparith.cc
1118
1119  basePack=(package)omAlloc0(sizeof(*basePack));
1120  currPack=basePack;
1121  idhdl h;
1122  h=enterid("Top", 0, PACKAGE_CMD, &IDROOT, TRUE);
1123  IDPACKAGE(h)->language = LANG_TOP;
1124  IDPACKAGE(h)=basePack;
1125  currPackHdl=h;
1126  basePackHdl=h;
1127
1128  coeffs_BIGINT = nInitChar(n_Q,NULL);
1129 
1130#if 1
1131   // def HAVE_POLYEXTENSIONS
1132  if(TRUE)
1133  {
1134    n_coeffType type = nRegister(n_algExt, naInitChar);
1135    assume(type == n_algExt);
1136     
1137    type = nRegister(n_transExt, ntInitChar);
1138    assume(type == n_transExt);
1139  }
1140#endif
1141
1142// random generator: -----------------------------------------------
1143  int t=initTimer();
1144  if (t==0) t=1;
1145  initRTimer();
1146  siSeed=t;
1147#ifdef HAVE_FACTORY
1148  factoryseed(t);
1149#endif
1150  siRandomStart=t;
1151  feOptSpec[FE_OPT_RANDOM].value = (void*) ((long)siRandomStart);
1152
1153// ressource table: ----------------------------------------------------
1154  // Don't worry: ifdef OM_NDEBUG, then all these calls are undef'ed
1155  // hack such that all shared' libs in the bindir are loaded correctly
1156  feInitResources(name);
1157
1158// singular links: --------------------------------------------------
1159  slStandardInit();
1160  myynest=0;
1161
1162// loading standard.lib -----------------------------------------------
1163  if (! feOptValue(FE_OPT_NO_STDLIB))
1164  {
1165    int vv=verbose;
1166    verbose &= ~Sy_bit(V_LOAD_LIB);
1167    iiLibCmd(omStrDup("standard.lib"), TRUE,TRUE,TRUE);
1168    verbose=vv;
1169  }
1170  errorreported = 0;
1171}
1172
1173/*
1174#ifdef LIBSINGULAR
1175#ifdef HAVE_FACTORY
1176// the init routines of factory need mmInit
1177int mmInit( void )
1178{
1179  return 1;
1180}
1181#endif
1182#endif
1183*/
Note: See TracBrowser for help on using the repository browser.