source: git/Singular/misc_ip.cc @ 65b813

fieker-DuValspielwiese
Last change on this file since 65b813 was 65b813, checked in by Hans Schoenemann <hannes@…>, 12 years ago
fix: primefactors(): result and algorithm, bound enabled again Conflicts: Singular/ChangeLog Singular/iparith.cc
  • Property mode set to 100644
File size: 28.3 KB
Line 
1/*****************************************************************************\
2 * Computer Algebra System SINGULAR
3\*****************************************************************************/
4/** @file misc_ip.cc
5 *
6 * This file provides miscellaneous functionality.
7 *
8 * For more general information, see the documentation in misc_ip.h.
9 *
10 **/
11/*****************************************************************************/
12
13// include header files
14#include <misc/auxiliary.h>
15#include "config.h"
16#include <kernel/mod2.h>
17
18#ifdef HAVE_FACTORY
19#define SI_DONT_HAVE_GLOBAL_VARS
20#include <factory/factory.h>
21#endif
22
23#include <coeffs/si_gmp.h>
24#include <coeffs/coeffs.h>
25
26#include <polys/ext_fields/algext.h>
27#include <polys/ext_fields/transext.h>
28
29#include "misc_ip.h"
30#include "ipid.h"
31#include "feOpt.h"
32#include "silink.h"
33
34// the following 2 inline functions are just convenience shortcuts for Frank's code:
35static inline void number2mpz(number n, mpz_t m){ n_MPZ(m, n, coeffs_BIGINT); }
36static inline number mpz2number(mpz_t m){ return n_InitMPZ(m, coeffs_BIGINT); }
37
38
39void setListEntry(lists L, int index, mpz_t n)
40{ /* assumes n > 0 */
41  /* try to fit nn into an int: */
42  if (mpz_size1(n)<=1)
43  {
44    int ui=(int)mpz_get_si(n);
45    if ((((ui<<3)>>3)==ui)
46    && (mpz_cmp_si(n,(long)ui)==0))
47    {
48      L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)ui;
49      return;
50    }
51  }
52  number nn = mpz2number(n);
53  L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
54}
55
56void setListEntry_ui(lists L, int index, unsigned long ui)
57{ /* assumes n > 0 */
58  /* try to fit nn into an int: */
59  int i=(int)ui;
60  if ((((unsigned long)i)==ui) && (((i<<3)>>3)==i))
61  {
62    L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)i;
63  }
64  else
65  {
66    number nn = n_Init(ui, coeffs_BIGINT);
67    L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
68  }
69}
70
71
72/* Factoring with Pollard's rho method. stolen from GMP/demos */
73static unsigned add[] = {4, 2, 4, 2, 4, 6, 2, 6};
74
75int factor_using_division (mpz_t t, unsigned int limit,lists primes, int *multiplicities,int &index, unsigned long bound)
76{
77  mpz_t q, r;
78  unsigned long int f;
79  int ai;
80  unsigned *addv = add;
81  unsigned int failures;
82  int bound_not_reached=1;
83
84  mpz_init (q);
85  mpz_init (r);
86
87  f = mpz_scan1 (t, 0);
88  mpz_div_2exp (t, t, f);
89  if (f>0)
90  {
91    setListEntry_ui(primes, index, 2);
92    multiplicities[index++] = f;
93  }
94
95  f=0;
96  loop
97  {
98    mpz_tdiv_qr_ui (q, r, t, 3);
99    if (mpz_cmp_ui (r, 0) != 0)
100        break;
101    mpz_set (t, q);
102    f++;
103  }
104  if (f>0)
105  {
106    setListEntry_ui(primes, index, 3);
107    multiplicities[index++] = f;
108  }
109  f=0;
110  loop
111  {
112    mpz_tdiv_qr_ui (q, r, t, 5);
113    if (mpz_cmp_ui (r, 0) != 0)
114        break;
115    mpz_set (t, q);
116    f++;
117  }
118  if (f>0)
119  {
120    setListEntry_ui(primes, index, 5);
121    multiplicities[index++] = f;
122  }
123
124  failures = 0;
125  f = 7;
126  ai = 0;
127  unsigned long last_f=0;
128  while (mpz_cmp_ui (t, 1) != 0)
129  {
130    mpz_tdiv_qr_ui (q, r, t, f);
131    if (mpz_cmp_ui (r, 0) != 0)
132    {
133      f += addv[ai];
134      if (mpz_cmp_ui (t, f) < 0)
135        break;
136      ai = (ai + 1) & 7;
137      failures++;
138      if (failures > limit)
139        break;
140      if ((bound!=0) && (f>bound))
141      {
142        bound_not_reached=0;
143        break;
144      }
145    }
146    else
147    {
148      mpz_swap (t, q);
149      if (f!=last_f)
150      {
151        setListEntry_ui(primes, index, f);
152        multiplicities[index]++;
153        index++;
154      }
155      else
156      {
157        multiplicities[index-1]++;
158      }
159      last_f=f;
160      failures = 0;
161    }
162  }
163
164  mpz_clears (q, r, NULL);
165  //printf("bound=%d,f=%d,failures=%d, reached=%d\n",bound,f,failures,bound_not_reached);
166  return bound_not_reached;
167}
168
169void factor_using_pollard_rho (mpz_t n, unsigned long a, lists primes, int * multiplicities,int &index)
170{
171  mpz_t x, x1, y, P;
172  mpz_t t1, t2;
173  mpz_t last_f;
174  unsigned long long k, l, i;
175
176  mpz_init (t1);
177  mpz_init (t2);
178  mpz_init_set_si (last_f, 0);
179  mpz_init_set_si (y, 2);
180  mpz_init_set_si (x, 2);
181  mpz_init_set_si (x1, 2);
182  mpz_init_set_ui (P, 1);
183  k = 1;
184  l = 1;
185
186  while (mpz_cmp_ui (n, 1) != 0)
187  {
188    loop
189    {
190      do
191      {
192        mpz_mul (t1, x, x);
193        mpz_mod (x, t1, n);
194        mpz_add_ui (x, x, a);
195        mpz_sub (t1, x1, x);
196        mpz_mul (t2, P, t1);
197        mpz_mod (P, t2, n);
198
199        if (k % 32 == 1)
200        {
201          mpz_gcd (t1, P, n);
202          if (mpz_cmp_ui (t1, 1) != 0)
203            goto factor_found;
204          mpz_set (y, x);
205        }
206      }
207      while (--k != 0);
208
209      mpz_gcd (t1, P, n);
210      if (mpz_cmp_ui (t1, 1) != 0)
211        goto factor_found;
212
213      mpz_set (x1, x);
214      k = l;
215      l = 2 * l;
216      for (i = 0; i < k; i++)
217      {
218        mpz_mul (t1, x, x);
219        mpz_mod (x, t1, n);
220        mpz_add_ui (x, x, a);
221      }
222      mpz_set (y, x);
223    }
224
225  factor_found:
226    do
227    {
228      mpz_mul (t1, y, y);
229      mpz_mod (y, t1, n);
230      mpz_add_ui (y, y, a);
231      mpz_sub (t1, x1, y);
232      mpz_gcd (t1, t1, n);
233    }
234    while (mpz_cmp_ui (t1, 1) == 0);
235
236    mpz_divexact (n, n, t1);        /* divide by t1, before t1 is overwritten */
237
238    if (!mpz_probab_prime_p (t1, 10))
239    {
240      do
241      {
242        mp_limb_t a_limb;
243        mpn_random (&a_limb, (mp_size_t) 1);
244        a = a_limb;
245      }
246      while (a == 0);
247
248      factor_using_pollard_rho (t1, a, primes,multiplicities,index);
249    }
250    else
251    {
252      if (mpz_cmp(t1,last_f)==0)
253      {
254        multiplicities[index-1]++;
255      }
256      else
257      {
258        mpz_set(last_f,t1);
259        setListEntry(primes, index, t1);
260        multiplicities[index++] = 1;
261      }
262    }
263    mpz_mod (x, x, n);
264    mpz_mod (x1, x1, n);
265    mpz_mod (y, y, n);
266    if (mpz_probab_prime_p (n, 10))
267    {
268      if (mpz_cmp(n,last_f)==0)
269      {
270        multiplicities[index-1]++;
271      }
272      else
273      {
274        mpz_set(last_f,n);
275        setListEntry(primes, index, n);
276        multiplicities[index++] = 1;
277      }
278      mpz_set_ui(n,1);
279      break;
280    }
281  }
282
283  mpz_clears (P,t2,t1,x1,x,y,last_f,NULL);
284}
285
286void factor (mpz_t t,lists primes,int *multiplicities,int &index,unsigned long bound)
287{
288  unsigned int division_limit;
289
290  if (mpz_sgn (t) == 0)
291    return;
292
293  /* Set the trial division limit according the size of t.  */
294  division_limit = mpz_sizeinbase (t, 2);
295  if (division_limit > 1000)
296    division_limit = 1000 * 1000;
297  else
298    division_limit = division_limit * division_limit;
299
300  if (factor_using_division (t, division_limit,primes,multiplicities,index,bound))
301  {
302    if (mpz_cmp_ui (t, 1) != 0)
303    {
304      if (mpz_probab_prime_p (t, 10))
305      {
306        setListEntry(primes, index, t);
307        multiplicities[index++] = 1;
308        mpz_set_ui(t,1);
309      }
310      else
311        factor_using_pollard_rho (t, 1L, primes,multiplicities,index);
312    }
313  }
314}
315/* n and pBound are assumed to be bigint numbers */
316lists primeFactorisation(const number n, const int pBound)
317{
318  int i;
319  int index=0;
320  mpz_t nn; number2mpz(n, nn);
321  lists primes = (lists)omAllocBin(slists_bin); primes->Init(1000);
322  int* multiplicities = (int*)omAlloc0(1000*sizeof(int));
323  int positive=1;
324
325  if (!n_IsZero(n, coeffs_BIGINT))
326  {
327    if (!n_GreaterZero(n, coeffs_BIGINT))
328    {
329      positive=-1;
330      mpz_neg(nn,nn);
331    }
332    factor(nn,primes,multiplicities,index,pBound);
333  }
334
335  lists primesL = (lists)omAllocBin(slists_bin);
336  primesL->Init(index);
337  for (i = 0; i < index; i++)
338  {
339    primesL->m[i].rtyp = primes->m[i].rtyp;
340    primesL->m[i].data = primes->m[i].data;
341  }
342  omFreeSize((ADDRESS)primes->m, (primes->nr + 1) * sizeof(sleftv));
343  omFreeBin((ADDRESS)primes, slists_bin);
344
345  lists multiplicitiesL = (lists)omAllocBin(slists_bin);
346  multiplicitiesL->Init(index);
347  for (i = 0; i < index; i++)
348  {
349    multiplicitiesL->m[i].rtyp = INT_CMD;
350    multiplicitiesL->m[i].data = (void*)multiplicities[i];
351  }
352  delete[] multiplicities;
353
354  lists L=(lists)omAllocBin(slists_bin);
355  L->Init(3);
356  if (positive==-1) mpz_neg(nn,nn);
357  L->m[0].rtyp = LIST_CMD; L->m[0].data = (void*)primesL;
358  L->m[1].rtyp = LIST_CMD; L->m[1].data = (void*)multiplicitiesL;
359  setListEntry(L, 2, nn);
360
361  mpz_clear(nn);
362
363  return L;
364}
365
366#include <omalloc/omalloc.h>
367#include <misc/mylimits.h>
368
369#include <misc/options.h>
370#include <misc/intvec.h>
371
372#include <polys/monomials/ring.h>
373#include <polys/templates/p_Procs.h>
374
375#include <kernel/febase.h>
376#include <kernel/kstd1.h>
377#include <kernel/timer.h>
378
379
380#include "subexpr.h"
381#include "cntrlc.h"
382#include "ipid.h"
383#include "ipshell.h"
384
385#include "version.h"
386
387#include "fehelp.h"
388
389#ifdef HAVE_STATIC
390#undef HAVE_DYN_RL
391#endif
392
393#define SI_DONT_HAVE_GLOBAL_VARS
394
395//#ifdef HAVE_LIBPARSER
396//#  include "libparse.h"
397//#endif /* HAVE_LIBPARSER */
398
399
400/*2
401* the renice routine for very large jobs
402* works only on unix machines,
403* testet on : linux, HP 9.0
404*
405*#include <sys/times.h>
406*#include <sys/resource.h>
407*extern "C" int setpriority(int,int,int);
408*void very_nice()
409*{
410*#ifndef NO_SETPRIORITY
411*  setpriority(PRIO_PROCESS,0,19);
412*#endif
413*  sleep(10);
414*}
415*/
416
417#include <string.h>
418#include <unistd.h>
419#include <stdio.h>
420#include <stddef.h>
421#include <stdlib.h>
422#include <time.h>
423
424
425void singular_example(char *str)
426{
427  assume(str!=NULL);
428  char *s=str;
429  while (*s==' ') s++;
430  char *ss=s;
431  while (*ss!='\0') ss++;
432  while (*ss<=' ')
433  {
434    *ss='\0';
435    ss--;
436  }
437  idhdl h=IDROOT->get(s,myynest);
438  if ((h!=NULL) && (IDTYP(h)==PROC_CMD))
439  {
440    char *lib=iiGetLibName(IDPROC(h));
441    if((lib!=NULL)&&(*lib!='\0'))
442    {
443      Print("// proc %s from lib %s\n",s,lib);
444      s=iiGetLibProcBuffer(IDPROC(h), 2);
445      if (s!=NULL)
446      {
447        if (strlen(s)>5)
448        {
449          iiEStart(s,IDPROC(h));
450          omFree((ADDRESS)s);
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      }
484      else
485      {
486        s[length] = '\0';
487        strcat(s, "\n;return();\n\n");
488        si_echo = 2;
489        iiEStart(s, NULL);
490        si_echo = old_echo;
491      }
492      omFree(s);
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]=si_opt_1;
598      (*w)[1]=si_opt_2;
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        si_opt_1=(*w)[0];
611        si_opt_2=(*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          si_opt_1 &=~Sy_bit(OPT_INTSTRATEGY);
620        }
621#endif
622        goto okay;
623      }
624    }
625    if(strcmp(n,"none")==0)
626    {
627      si_opt_1=0;
628      si_opt_2=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          si_opt_1 |= optionStruct[i].setval;
638          // optOldStd disables redthrough
639          if (optionStruct[i].setval == Sy_bit(OPT_OLDSTD))
640            si_opt_1 &= ~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          si_opt_1 &= 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        si_opt_2 |= 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        si_opt_2 &= 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 = si_opt_1 & TEST_RINGDEP_OPTS;
702    omFree((ADDRESS)n);
703    v=v->next;
704  } while (v!=NULL);
705
706#ifdef OM_SINGULAR_CONFIG_H
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#endif
712
713  return FALSE;
714}
715
716char * showOption()
717{
718  int i;
719  BITSET tmp;
720
721  StringSetS("//options:");
722  if ((si_opt_1!=0)||(si_opt_2!=0))
723  {
724    tmp=si_opt_1;
725    if(tmp)
726    {
727      for (i=0; optionStruct[i].setval!=0; i++)
728      {
729        if (optionStruct[i].setval & tmp)
730        {
731          StringAppend(" %s",optionStruct[i].name);
732          tmp &=optionStruct[i].resetval;
733        }
734      }
735      for (i=0; i<32; i++)
736      {
737        if (tmp & Sy_bit(i)) StringAppend(" %d",i);
738      }
739    }
740    tmp=si_opt_2;
741    if (tmp)
742    {
743      for (i=0; verboseStruct[i].setval!=0; i++)
744      {
745        if (verboseStruct[i].setval & tmp)
746        {
747          StringAppend(" %s",verboseStruct[i].name);
748          tmp &=verboseStruct[i].resetval;
749        }
750      }
751      for (i=1; i<32; i++)
752      {
753        if (tmp & Sy_bit(i)) StringAppend(" %d",i+32);
754      }
755    }
756    return StringEndS();
757  }
758  StringAppendS(" none");
759  return StringEndS();
760}
761
762char * versionString()
763{
764  StringSetS("");
765  StringAppend("Singular for %s version %s (%d-%s)  %s\nwith\n",
766               S_UNAME, S_VERSION1, SINGULAR_VERSION,
767               feVersionId,singular_date);
768  StringAppendS("\t");
769#ifdef HAVE_FACTORY
770  StringAppend("factory(%s)", factoryVersion);
771#ifdef HAVE_LIBFAC
772  // libfac:
773//  extern const char * libfac_version;
774//  extern const char * libfac_date;
775  StringAppend("+libfac");
776#endif // #ifdef HAVE_LIBFAC
777  StringAppend(",");
778#endif
779
780#if defined (__GNU_MP_VERSION) && defined (__GNU_MP_VERSION_MINOR)
781              StringAppend("GMP(%d.%d),",__GNU_MP_VERSION,__GNU_MP_VERSION_MINOR);
782#else
783              StringAppendS("GMP(1.3),");
784#endif
785#ifdef HAVE_NTL
786#include <NTL/version.h>
787              StringAppend("NTL(%s),",NTL_VERSION);
788#endif
789#if SIZEOF_VOIDP == 8
790              StringAppendS("64bit,");
791#else
792              StringAppendS("32bit,");
793#endif
794#if defined(HAVE_DYN_RL)
795              if (fe_fgets_stdin==fe_fgets_dummy)
796                StringAppendS("no input,");
797              else if (fe_fgets_stdin==fe_fgets)
798                StringAppendS("fgets,");
799              if (fe_fgets_stdin==fe_fgets_stdin_drl)
800                StringAppendS("dynamic readline,");
801              #ifdef HAVE_FEREAD
802              else if (fe_fgets_stdin==fe_fgets_stdin_emu)
803                StringAppendS("emulated readline,");
804              #endif
805              else
806                StringAppendS("unknown fgets method,");
807#else
808  #if defined(HAVE_READLINE) && !defined(FEREAD)
809              StringAppendS("static readline,");
810  #else
811    #ifdef HAVE_FEREAD
812              StringAppendS("emulated readline,");
813    #else
814              StringAppendS("fgets,");
815    #endif
816  #endif
817#endif
818#ifdef HAVE_PLURAL
819              StringAppendS("Plural,");
820#endif
821#ifdef HAVE_DBM
822              StringAppendS("DBM,\n\t");
823#else
824              StringAppendS("\n\t");
825#endif
826#ifdef HAVE_DYNAMIC_LOADING
827              StringAppendS("dynamic modules,");
828#endif
829              if (p_procs_dynamic) StringAppendS("dynamic p_Procs,");
830#ifdef TEST
831              StringAppendS("TESTs,");
832#endif
833#if YYDEBUG
834              StringAppendS("YYDEBUG=1,");
835#endif
836#ifdef HAVE_ASSUME
837             StringAppendS("ASSUME,");
838#endif
839#ifdef MDEBUG
840              StringAppend("MDEBUG=%d,",MDEBUG);
841#endif
842#ifdef OM_CHECK
843              StringAppend("OM_CHECK=%d,",OM_CHECK);
844#endif
845#ifdef OM_TRACK
846              StringAppend("OM_TRACK=%d,",OM_TRACK);
847#endif
848#ifdef OM_NDEBUG
849              StringAppendS("OM_NDEBUG,");
850#endif
851#ifdef PDEBUG
852              StringAppendS("PDEBUG,");
853#endif
854#ifdef KDEBUG
855              StringAppendS("KDEBUG,");
856#endif
857#ifndef __OPTIMIZE__
858              StringAppendS("-g,");
859#endif
860#ifdef HAVE_EIGENVAL
861              StringAppendS("eigenvalues,");
862#endif
863#ifdef HAVE_GMS
864              StringAppendS("Gauss-Manin system,");
865#endif
866#ifdef HAVE_RATGRING
867              StringAppendS("ratGB,");
868#endif
869              StringAppend("random=%d\n",siRandomStart);
870              StringAppend("\tCC=%s,\n\tCXX=%s"
871#ifdef __GNUC__
872              "(" __VERSION__ ")"
873#endif
874              "\n",CC,CXX);
875              feStringAppendResources(0);
876              feStringAppendBrowsers(0);
877              StringAppendS("\n");
878              return StringEndS();
879}
880
881#ifdef PDEBUG
882#if (OM_TRACK > 2) && defined(OM_TRACK_CUSTOM)
883void p_SetRingOfLeftv(leftv l, ring r)
884{
885  switch(l->rtyp)
886  {
887    case INT_CMD:
888    case BIGINT_CMD:
889    case IDHDL:
890    case DEF_CMD:
891      break;
892    case POLY_CMD:
893    case VECTOR_CMD:
894    {
895      poly p=(poly)l->data;
896      while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
897      break;
898    }
899    case IDEAL_CMD:
900    case MODUL_CMD:
901    case MATRIX_CMD:
902    {
903      ideal I=(ideal)l->data;
904      int i;
905      for(i=IDELEMS(I)-1;i>=0;i--)
906      {
907        poly p=I->m[i];
908        while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
909      }
910      break;
911    }
912    case COMMAND:
913    {
914      command d=(command)l->data;
915      p_SetRingOfLeftv(&d->arg1, r);
916      if (d->argc>1) p_SetRingOfLeftv(&d->arg2, r);
917      if (d->argc>2) p_SetRingOfLeftv(&d->arg3, r);
918      break;
919    }
920    default:
921     printf("type %d not yet implementd in p_SetRingOfLeftv\n",l->rtyp);
922     break;
923  }
924}
925#endif
926#endif
927
928#if 0 /* debug only */
929void listall(int showproc)
930{
931      idhdl hh=basePack->idroot;
932      PrintS("====== Top ==============\n");
933      while (hh!=NULL)
934      {
935        if (showproc || (IDTYP(hh)!=PROC_CMD))
936        {
937          if (IDDATA(hh)==(void *)currRing) PrintS("(R)");
938          else if (IDDATA(hh)==(void *)currPack) PrintS("(P)");
939          else PrintS("   ");
940          Print("::%s, typ %s level %d data %lx",
941                 IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
942          if ((IDTYP(hh)==RING_CMD)
943          || (IDTYP(hh)==QRING_CMD))
944            Print(" ref: %d\n",IDRING(hh)->ref);
945          else
946            PrintLn();
947        }
948        hh=IDNEXT(hh);
949      }
950      hh=basePack->idroot;
951      while (hh!=NULL)
952      {
953        if (IDDATA(hh)==(void *)basePack)
954          Print("(T)::%s, typ %s level %d data %lx\n",
955          IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
956        else
957        if ((IDTYP(hh)==RING_CMD)
958        || (IDTYP(hh)==QRING_CMD)
959        || (IDTYP(hh)==PACKAGE_CMD))
960        {
961          Print("====== %s ==============\n",IDID(hh));
962          idhdl h2=IDRING(hh)->idroot;
963          while (h2!=NULL)
964          {
965            if (showproc || (IDTYP(h2)!=PROC_CMD))
966            {
967              if ((IDDATA(h2)==(void *)currRing)
968              && ((IDTYP(h2)==RING_CMD)||(IDTYP(h2)==QRING_CMD)))
969                PrintS("(R)");
970              else if (IDDATA(h2)==(void *)currPack) PrintS("(P)");
971              else PrintS("   ");
972              Print("%s::%s, typ %s level %d data %lx\n",
973              IDID(hh),IDID(h2),Tok2Cmdname(IDTYP(h2)),IDLEV(h2),(long)IDDATA(h2));
974            }
975            h2=IDNEXT(h2);
976          }
977        }
978        hh=IDNEXT(hh);
979      }
980      Print("currRing:%lx, currPack:%lx,basePack:%lx\n",(long)currRing,(long)currPack,(long)basePack);
981      iiCheckPack(currPack);
982}
983#endif
984
985#ifndef NDEBUG
986void checkall()
987{
988      idhdl hh=basePack->idroot;
989      while (hh!=NULL)
990      {
991        omCheckAddr(hh);
992        omCheckAddr((ADDRESS)IDID(hh));
993        if (RingDependend(IDTYP(hh))) Print("%s typ %d in Top\n",IDID(hh),IDTYP(hh));
994        hh=IDNEXT(hh);
995      }
996      hh=basePack->idroot;
997      while (hh!=NULL)
998      {
999        if (IDTYP(hh)==PACKAGE_CMD)
1000        {
1001          idhdl h2=IDPACKAGE(hh)->idroot;
1002          while (h2!=NULL)
1003          {
1004            omCheckAddr(h2);
1005            omCheckAddr((ADDRESS)IDID(h2));
1006            if (RingDependend(IDTYP(h2))) Print("%s typ %d in %s\n",IDID(h2),IDTYP(h2),IDID(hh));
1007            h2=IDNEXT(h2);
1008          }
1009        }
1010        hh=IDNEXT(hh);
1011      }
1012}
1013#endif
1014
1015#include <sys/types.h>
1016#include <sys/stat.h>
1017#include <unistd.h>
1018
1019extern "C"
1020int singular_fstat(int fd, struct stat *buf)
1021{
1022  return fstat(fd,buf);
1023}
1024
1025/*2
1026* the global exit routine of Singular
1027*/
1028extern "C" {
1029
1030void m2_end(int i)
1031{
1032  fe_reset_input_mode();
1033  #ifdef PAGE_TEST
1034  mmEndStat();
1035  #endif
1036  fe_reset_input_mode();
1037  idhdl h = IDROOT;
1038  while(h != NULL)
1039  {
1040    if(IDTYP(h) == LINK_CMD)
1041    {
1042      idhdl hh=h->next;
1043      killhdl(h, currPack);
1044      h = hh;
1045    }
1046    else
1047    {
1048      h = h->next;
1049    }
1050  }
1051  if(!singular_in_batchmode)
1052  {
1053    if (i<=0)
1054    {
1055      if (TEST_V_QUIET)
1056      {
1057        if (i==0)
1058          printf("Auf Wiedersehen.\n");
1059        else
1060          printf("\n$Bye.\n");
1061      }
1062      //#ifdef sun
1063      //  #ifndef __svr4__
1064      //    _cleanup();
1065      //    _exit(0);
1066      //  #endif
1067      //#endif
1068      i=0;
1069    }
1070    else
1071    {
1072        printf("\nhalt %d\n",i);
1073    }
1074  }
1075  exit(i);
1076}
1077}
1078
1079const char *singular_date=__DATE__ " " __TIME__;
1080
1081extern "C"
1082{
1083  void omSingOutOfMemoryFunc()
1084  {
1085    fprintf(stderr, "\nSingular error: no more memory\n");
1086    omPrintStats(stderr);
1087    m2_end(14);
1088    /* should never get here */
1089    exit(1);
1090  }
1091}
1092
1093/*2
1094* initialize components of Singular
1095*/
1096void siInit(char *name)
1097{
1098#ifdef HAVE_FACTORY
1099// factory default settings: -----------------------------------------------
1100  On(SW_USE_NTL);
1101  On(SW_USE_NTL_GCD_0); // On -> seg11 in Old/algnorm, Old/factor...
1102  On(SW_USE_NTL_GCD_P); // On -> cyle in Short/brnoeth_s: fixed
1103  On(SW_USE_EZGCD);
1104  On(SW_USE_CHINREM_GCD);
1105  //On(SW_USE_FF_MOD_GCD);
1106  On(SW_USE_EZGCD_P);
1107  On(SW_USE_QGCD);
1108  Off(SW_USE_NTL_SORT); // may be changed by an command line option
1109  factoryError=WerrorS;
1110#endif
1111
1112// memory initialization: -----------------------------------------------
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// interpreter tables etc.: -----------------------------------------------
1125#ifdef INIT_BUG
1126  jjInitTab1();
1127#endif
1128  memset(&sLastPrinted,0,sizeof(sleftv));
1129  sLastPrinted.rtyp=NONE;
1130
1131  extern int iiInitArithmetic(); iiInitArithmetic(); // iparith.cc
1132
1133  basePack=(package)omAlloc0(sizeof(*basePack));
1134  currPack=basePack;
1135  idhdl h;
1136  h=enterid("Top", 0, PACKAGE_CMD, &IDROOT, TRUE);
1137  IDPACKAGE(h)->language = LANG_TOP;
1138  IDPACKAGE(h)=basePack;
1139  currPackHdl=h;
1140  basePackHdl=h;
1141
1142  coeffs_BIGINT = nInitChar(n_Q,NULL);
1143
1144#if 1
1145   // def HAVE_POLYEXTENSIONS
1146  if(TRUE)
1147  {
1148    n_coeffType type = nRegister(n_algExt, naInitChar);
1149    assume(type == n_algExt);
1150
1151    type = nRegister(n_transExt, ntInitChar);
1152    assume(type == n_transExt);
1153     
1154    (void)type;
1155  }
1156#endif
1157
1158// random generator: -----------------------------------------------
1159  int t=initTimer();
1160  if (t==0) t=1;
1161  initRTimer();
1162  siSeed=t;
1163#ifdef HAVE_FACTORY
1164  factoryseed(t);
1165#endif
1166  siRandomStart=t;
1167  feOptSpec[FE_OPT_RANDOM].value = (void*) ((long)siRandomStart);
1168
1169// ressource table: ----------------------------------------------------
1170  // Don't worry: ifdef OM_NDEBUG, then all these calls are undef'ed
1171  // hack such that all shared' libs in the bindir are loaded correctly
1172  feInitResources(name);
1173
1174// singular links: --------------------------------------------------
1175  slStandardInit();
1176  myynest=0;
1177
1178// loading standard.lib -----------------------------------------------
1179  if (! feOptValue(FE_OPT_NO_STDLIB))
1180  {
1181    BITSET save1,save2;
1182    SI_SAVE_OPT(save1,save2);
1183    si_opt_2 &= ~Sy_bit(V_LOAD_LIB);
1184    iiLibCmd(omStrDup("standard.lib"), TRUE,TRUE,TRUE);
1185    SI_RESTORE_OPT(save1,save2);
1186  }
1187  errorreported = 0;
1188}
1189
1190/*
1191#ifdef LIBSINGULAR
1192#ifdef HAVE_FACTORY
1193// the init routines of factory need mmInit
1194int mmInit( void )
1195{
1196  return 1;
1197}
1198#endif
1199#endif
1200*/
Note: See TracBrowser for help on using the repository browser.