My Project  debian-1:4.1.1-p2+ds-4
extra.cc
Go to the documentation of this file.
1 /*****************************************
2 * Computer Algebra System SINGULAR *
3 *****************************************/
4 /*
5 * ABSTRACT: general interface to internals of Singular ("system" command)
6 * jjSYSTEM: official commands, must be documented in the manual,
7 * #defines must be local to each command
8 * jjEXTENDED_SYSTEM: tests, temporary comands etc.
9 */
10 
11 #define HAVE_WALK 1
12 
13 #include "kernel/mod2.h"
14 #include "misc/sirandom.h"
15 #include "resources/omFindExec.h"
16 
17 #include "factory/factory.h"
18 
19 #ifdef TIME_WITH_SYS_TIME
20 # include <time.h>
21 # ifdef HAVE_SYS_TIME_H
22 # include <sys/time.h>
23 # endif
24 #else
25 # ifdef HAVE_SYS_TIME_H
26 # include <sys/time.h>
27 # else
28 # include <time.h>
29 # endif
30 #endif
31 #ifdef HAVE_SYS_TIMES_H
32 #include <sys/times.h>
33 #endif
34 
35 #include <unistd.h>
36 
37 #include "misc/options.h"
38 
39 // #include "coeffs/ffields.h"
40 #include "coeffs/coeffs.h"
41 #include "coeffs/mpr_complex.h"
42 #include "coeffs/AE.h"
43 // #include "coeffs/OPAE.h"
44 #include "coeffs/AEp.h"
45 // #include "coeffs/OPAEp.h"
46 #include "coeffs/AEQ.h"
47 // #include "coeffs/OPAEQ.h"
48 
49 
50 #include "resources/feResource.h"
51 #include "polys/monomials/ring.h"
52 #include "kernel/polys.h"
53 
54 #include "polys/monomials/maps.h"
55 #include "polys/matpol.h"
56 
57 #include "polys/weight.h"
58 
59 #include "coeffs/bigintmat.h"
60 #include "kernel/fast_mult.h"
61 #include "kernel/digitech.h"
63 #include "kernel/ideals.h"
64 #include "kernel/GBEngine/kstd1.h"
65 #include "kernel/GBEngine/syz.h"
66 #include "kernel/GBEngine/kutil.h"
67 
70 
72 
73 // for tests of t-rep-GB
74 #include "kernel/GBEngine/tgb.h"
75 
77 
78 #include "numeric/mpr_base.h"
79 
80 #include "tok.h"
81 #include "ipid.h"
82 #include "lists.h"
83 #include "cntrlc.h"
84 #include "ipshell.h"
85 #include "sdb.h"
86 #include "feOpt.h"
87 #include "fehelp.h"
88 #include "distrib.h"
89 
90 #include "misc_ip.h"
91 
92 #include "attrib.h"
93 
94 #include "links/silink.h"
95 #include "links/ssiLink.h"
96 #include "walk.h"
97 #include "Singular/newstruct.h"
98 #include "Singular/blackbox.h"
100 
101 
102 #ifdef HAVE_RINGS
103 #include "kernel/GBEngine/ringgb.h"
104 #endif
105 
106 #ifdef HAVE_F5
107 #include "kernel/GBEngine/f5gb.h"
108 #endif
109 
110 #ifdef HAVE_WALK
111 #include "walk.h"
112 #endif
113 
114 #ifdef HAVE_SPECTRUM
116 #endif
117 
118 #ifdef HAVE_PLURAL
119 #include "polys/nc/nc.h"
120 #include "polys/nc/ncSAMult.h" // for CMultiplier etc classes
121 #include "polys/nc/sca.h"
122 #include "kernel/GBEngine/nc.h"
123 #include "ipconv.h"
124 #ifdef HAVE_RATGRING
126 #endif
127 #endif
128 
129 #ifdef __CYGWIN__ /* only for the DLLTest */
130 /* #include "WinDllTest.h" */
131 #ifdef HAVE_DL
132 #include "polys/mod_raw.h"
133 #endif
134 #endif
135 
136 // Define to enable many more system commands
137 //#undef MAKE_DISTRIBUTION
138 #ifndef MAKE_DISTRIBUTION
139 #define HAVE_EXTENDED_SYSTEM 1
140 #endif
141 
142 #include "polys/flintconv.h"
143 #include "polys/clapconv.h"
144 #include "kernel/GBEngine/kstdfac.h"
145 
146 #include "polys/clapsing.h"
147 
148 #ifdef HAVE_EIGENVAL
149 #include "eigenval_ip.h"
150 #endif
151 
152 #ifdef HAVE_GMS
153 #include "gms.h"
154 #endif
155 
156 #ifdef HAVE_SIMPLEIPC
158 #endif
159 
160 #ifdef HAVE_PCV
161 #include "pcv.h"
162 #endif
163 
164 #ifndef MAKE_DISTRIBUTION
166 #endif
167 
168 /* expects a SINGULAR square matrix with number entries
169  where currRing is expected to be over some field F_p;
170  returns a long** matrix with the "same", i.e.,
171  appropriately mapped entries;
172  leaves singularMatrix unmodified */
173 unsigned long** singularMatrixToLongMatrix(matrix singularMatrix)
174 {
175  int n = singularMatrix->rows();
176  assume(n == singularMatrix->cols());
177  unsigned long **longMatrix = 0;
178  longMatrix = new unsigned long *[n] ;
179  for (int i = 0 ; i < n; i++)
180  longMatrix[i] = new unsigned long [n];
181  number entry;
182  for (int r = 0; r < n; r++)
183  for (int c = 0; c < n; c++)
184  {
185  poly p=MATELEM(singularMatrix, r + 1, c + 1);
186  int entryAsInt;
187  if (p!=NULL)
188  {
189  entry = p_GetCoeff(p, currRing);
190  entryAsInt = n_Int(entry, currRing->cf);
191  if (entryAsInt < 0) entryAsInt += n_GetChar(currRing->cf);
192  }
193  else
194  entryAsInt=0;
195  longMatrix[r][c] = (unsigned long)entryAsInt;
196  }
197  return longMatrix;
198 }
199 
200 /* expects an array of unsigned longs with valid indices 0..degree;
201  returns the following poly, where x denotes the first ring variable
202  of currRing, and d = degree:
203  polyCoeffs[d] * x^d + polyCoeffs[d-1] * x^(d-1) + ... + polyCoeffs[0]
204  leaves polyCoeffs unmodified */
205 poly longCoeffsToSingularPoly(unsigned long *polyCoeffs, const int degree)
206 {
207  poly result = NULL;
208  for (int i = 0; i <= degree; i++)
209  {
210  if ((int)polyCoeffs[i] != 0)
211  {
212  poly term = p_ISet((int)polyCoeffs[i], currRing);
213  if (i > 0)
214  {
215  p_SetExp(term, 1, i, currRing);
216  p_Setm(term, currRing);
217  }
219  }
220  }
221  return result;
222 }
223 
224 //void emStart();
225 /*2
226 * the "system" command
227 */
229 {
230  if(args->Typ() == STRING_CMD)
231  {
232  const char *sys_cmd=(char *)(args->Data());
233  leftv h=args->next;
234 // ONLY documented system calls go here
235 // Undocumented system calls go down into jjEXTENDED_SYSTEM (#ifdef HAVE_EXTENDED_SYSTEM)
236 /*==================== nblocks ==================================*/
237  if (strcmp(sys_cmd, "nblocks") == 0)
238  {
239  ring r;
240  if (h == NULL)
241  {
242  if (currRingHdl != NULL)
243  {
244  r = IDRING(currRingHdl);
245  }
246  else
247  {
248  WerrorS("no ring active");
249  return TRUE;
250  }
251  }
252  else
253  {
254  if (h->Typ() != RING_CMD)
255  {
256  WerrorS("ring expected");
257  return TRUE;
258  }
259  r = (ring) h->Data();
260  }
261  res->rtyp = INT_CMD;
262  res->data = (void*) (long)(rBlocks(r) - 1);
263  return FALSE;
264  }
265 /*==================== version ==================================*/
266  if(strcmp(sys_cmd,"version")==0)
267  {
268  res->rtyp=INT_CMD;
269  res->data=(void *)SINGULAR_VERSION;
270  return FALSE;
271  }
272  else
273 /*==================== alarm ==================================*/
274  if(strcmp(sys_cmd,"alarm")==0)
275  {
276  if ((h!=NULL) &&(h->Typ()==INT_CMD))
277  {
278  // standard variant -> SIGALARM (standard: abort)
279  //alarm((unsigned)h->next->Data());
280  // process time (user +system): SIGVTALARM
281  struct itimerval t,o;
282  memset(&t,0,sizeof(t));
283  t.it_value.tv_sec =(unsigned)((unsigned long)h->Data());
284  setitimer(ITIMER_VIRTUAL,&t,&o);
285  return FALSE;
286  }
287  else
288  WerrorS("int expected");
289  }
290  else
291 /*==================== cpu ==================================*/
292  if(strcmp(sys_cmd,"cpu")==0)
293  {
294  long cpu=1; //feOptValue(FE_OPT_CPUS);
295  #ifdef _SC_NPROCESSORS_ONLN
296  cpu=sysconf(_SC_NPROCESSORS_ONLN);
297  #elif defined(_SC_NPROCESSORS_CONF)
298  cpu=sysconf(_SC_NPROCESSORS_CONF);
299  #endif
300  res->data=(void *)cpu;
301  res->rtyp=INT_CMD;
302  return FALSE;
303  }
304  else
305 /*==================== executable ==================================*/
306  if(strcmp(sys_cmd,"executable")==0)
307  {
308  if ((h!=NULL) && (h->Typ()==STRING_CMD))
309  {
310  char tbuf[MAXPATHLEN];
311  char *s=omFindExec((char*)h->Data(),tbuf);
312  if(s==NULL) s=(char*)"";
313  res->data=(void *)omStrDup(s);
314  res->rtyp=STRING_CMD;
315  return FALSE;
316  }
317  return TRUE;
318  }
319  else
320  /*==================== neworder =============================*/
321  if(strcmp(sys_cmd,"neworder")==0)
322  {
323  if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
324  {
325  res->rtyp=STRING_CMD;
326  res->data=(void *)singclap_neworder((ideal)h->Data(), currRing);
327  return FALSE;
328  }
329  else
330  WerrorS("ideal expected");
331  }
332  else
333 /*===== nc_hilb ===============================================*/
334  // Hilbert series of non-commutative monomial algebras
335  if(strcmp(sys_cmd,"nc_hilb") == 0)
336  {
337  ideal i; int lV;
338  bool ig = FALSE;
339  bool mgrad = FALSE;
340  bool autop = FALSE;
341  int trunDegHs=0;
342  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
343  i = (ideal)h->Data();
344  else
345  {
346  WerrorS("nc_Hilb:ideal expected");
347  return TRUE;
348  }
349  h = h->next;
350  if((h != NULL)&&(h->Typ() == INT_CMD))
351  lV = (int)(long)h->Data();
352  else
353  {
354  WerrorS("nc_Hilb:int expected");
355  return TRUE;
356  }
357  h = h->next;
358  while(h != NULL)
359  {
360  if((int)(long)h->Data() == 1)
361  ig = TRUE;
362  else if((int)(long)h->Data() == 2)
363  mgrad = TRUE;
364  else if(h->Typ()==STRING_CMD)
365  autop = TRUE;
366  else if(h->Typ() == INT_CMD)
367  trunDegHs = (int)(long)h->Data();
368  h = h->next;
369  }
370  if(h != NULL)
371  {
372  WerrorS("nc_Hilb:int 1,2, total degree for the truncation, and a string for printing the details are expected");
373  return TRUE;
374  }
375 
376  HilbertSeries_OrbitData(i, lV, ig, mgrad, autop, trunDegHs);
377  return(FALSE);
378  }
379  else
380 /*===== rcolon ===============================================*/
381  if(strcmp(sys_cmd,"rcolon") == 0)
382  {
383  const short t1[]={3,IDEAL_CMD,POLY_CMD,INT_CMD};
384  if (iiCheckTypes(h,t1,1))
385  {
386  ideal i = (ideal)h->Data();
387  h = h->next;
388  poly w=(poly)h->Data();
389  h = h->next;
390  int lV = (int)(long)h->Data();
391  res->rtyp = IDEAL_CMD;
392  res->data = RightColonOperation(i, w, lV);
393  return(FALSE);
394  }
395  else
396  return TRUE;
397  }
398  else
399 
400 /*==================== sh ==================================*/
401  if(strcmp(sys_cmd,"sh")==0)
402  {
403  if (feOptValue(FE_OPT_NO_SHELL))
404  {
405  WerrorS("shell execution is disallowed in restricted mode");
406  return TRUE;
407  }
408  res->rtyp=INT_CMD;
409  if (h==NULL) res->data = (void *)(long) system("sh");
410  else if (h->Typ()==STRING_CMD)
411  res->data = (void*)(long) system((char*)(h->Data()));
412  else
413  WerrorS("string expected");
414  return FALSE;
415  }
416  else
417 /*========reduce procedure like the global one but with jet bounds=======*/
418  if(strcmp(sys_cmd,"reduce_bound")==0)
419  {
420  poly p;
421  ideal pid=NULL;
422  const short t1[]={3,POLY_CMD,IDEAL_CMD,INT_CMD};
423  const short t2[]={3,IDEAL_CMD,IDEAL_CMD,INT_CMD};
424  const short t3[]={3,VECTOR_CMD,MODUL_CMD,INT_CMD};
425  const short t4[]={3,MODUL_CMD,MODUL_CMD,INT_CMD};
426  if ((iiCheckTypes(h,t1,0))||((iiCheckTypes(h,t3,0))))
427  {
428  p = (poly)h->CopyD();
429  }
430  else if ((iiCheckTypes(h,t2,0))||(iiCheckTypes(h,t4,1)))
431  {
432  pid = (ideal)h->CopyD();
433  }
434  else return TRUE;
435  //int htype;
436  res->rtyp= h->Typ(); /*htype*/
437  ideal q = (ideal)h->next->CopyD();
438  int bound = (int)(long)h->next->next->Data();
439  if (pid==NULL) /*(htype == POLY_CMD || htype == VECTOR_CMD)*/
440  res->data = (char *)kNFBound(q,currRing->qideal,p,bound);
441  else /*(htype == IDEAL_CMD || htype == MODUL_CMD)*/
442  res->data = (char *)kNFBound(q,currRing->qideal,pid,bound);
443  return FALSE;
444  }
445  else
446 /*==================== uname ==================================*/
447  if(strcmp(sys_cmd,"uname")==0)
448  {
449  res->rtyp=STRING_CMD;
450  res->data = omStrDup(S_UNAME);
451  return FALSE;
452  }
453  else
454 /*==================== with ==================================*/
455  if(strcmp(sys_cmd,"with")==0)
456  {
457  if (h==NULL)
458  {
459  res->rtyp=STRING_CMD;
460  res->data=(void *)versionString();
461  return FALSE;
462  }
463  else if (h->Typ()==STRING_CMD)
464  {
465  #define TEST_FOR(A) if(strcmp(s,A)==0) res->data=(void *)1; else
466  char *s=(char *)h->Data();
467  res->rtyp=INT_CMD;
468  #ifdef HAVE_DBM
469  TEST_FOR("DBM")
470  #endif
471  #ifdef HAVE_DLD
472  TEST_FOR("DLD")
473  #endif
474  //TEST_FOR("factory")
475  //TEST_FOR("libfac")
476  #ifdef HAVE_READLINE
477  TEST_FOR("readline")
478  #endif
479  #ifdef TEST_MAC_ORDER
480  TEST_FOR("MAC_ORDER")
481  #endif
482  // unconditional since 3-1-0-6
483  TEST_FOR("Namespaces")
484  #ifdef HAVE_DYNAMIC_LOADING
485  TEST_FOR("DynamicLoading")
486  #endif
487  #ifdef HAVE_EIGENVAL
488  TEST_FOR("eigenval")
489  #endif
490  #ifdef HAVE_GMS
491  TEST_FOR("gms")
492  #endif
493  #ifdef OM_NDEBUG
494  TEST_FOR("om_ndebug")
495  #endif
496  #ifdef SING_NDEBUG
497  TEST_FOR("ndebug")
498  #endif
499  {};
500  return FALSE;
501  #undef TEST_FOR
502  }
503  return TRUE;
504  }
505  else
506  /*==================== browsers ==================================*/
507  if (strcmp(sys_cmd,"browsers")==0)
508  {
509  res->rtyp = STRING_CMD;
510  StringSetS("");
512  res->data = StringEndS();
513  return FALSE;
514  }
515  else
516  /*==================== pid ==================================*/
517  if (strcmp(sys_cmd,"pid")==0)
518  {
519  res->rtyp=INT_CMD;
520  res->data=(void *)(long) getpid();
521  return FALSE;
522  }
523  else
524  /*==================== getenv ==================================*/
525  if (strcmp(sys_cmd,"getenv")==0)
526  {
527  if ((h!=NULL) && (h->Typ()==STRING_CMD))
528  {
529  res->rtyp=STRING_CMD;
530  const char *r=getenv((char *)h->Data());
531  if (r==NULL) r="";
532  res->data=(void *)omStrDup(r);
533  return FALSE;
534  }
535  else
536  {
537  WerrorS("string expected");
538  return TRUE;
539  }
540  }
541  else
542  /*==================== setenv ==================================*/
543  if (strcmp(sys_cmd,"setenv")==0)
544  {
545  #ifdef HAVE_SETENV
546  const short t[]={2,STRING_CMD,STRING_CMD};
547  if (iiCheckTypes(h,t,1))
548  {
549  res->rtyp=STRING_CMD;
550  setenv((char *)h->Data(), (char *)h->next->Data(), 1);
551  res->data=(void *)omStrDup((char *)h->next->Data());
553  return FALSE;
554  }
555  else
556  {
557  return TRUE;
558  }
559  #else
560  WerrorS("setenv not supported on this platform");
561  return TRUE;
562  #endif
563  }
564  else
565  /*==================== Singular ==================================*/
566  if (strcmp(sys_cmd, "Singular") == 0)
567  {
568  res->rtyp=STRING_CMD;
569  const char *r=feResource("Singular");
570  if (r == NULL) r="";
571  res->data = (void*) omStrDup( r );
572  return FALSE;
573  }
574  else
575  if (strcmp(sys_cmd, "SingularLib") == 0)
576  {
577  res->rtyp=STRING_CMD;
578  const char *r=feResource("SearchPath");
579  if (r == NULL) r="";
580  res->data = (void*) omStrDup( r );
581  return FALSE;
582  }
583  else
584  /*==================== options ==================================*/
585  if (strstr(sys_cmd, "--") == sys_cmd)
586  {
587  if (strcmp(sys_cmd, "--") == 0)
588  {
590  return FALSE;
591  }
592  feOptIndex opt = feGetOptIndex(&sys_cmd[2]);
593  if (opt == FE_OPT_UNDEF)
594  {
595  Werror("Unknown option %s", sys_cmd);
596  WerrorS("Use 'system(\"--\");' for listing of available options");
597  return TRUE;
598  }
599  // for Untyped Options (help version),
600  // setting it just triggers action
601  if (feOptSpec[opt].type == feOptUntyped)
602  {
603  feSetOptValue(opt,0);
604  return FALSE;
605  }
606  if (h == NULL)
607  {
608  if (feOptSpec[opt].type == feOptString)
609  {
610  res->rtyp = STRING_CMD;
611  const char *r=(const char*)feOptSpec[opt].value;
612  if (r == NULL) r="";
613  res->data = omStrDup(r);
614  }
615  else
616  {
617  res->rtyp = INT_CMD;
618  res->data = feOptSpec[opt].value;
619  }
620  return FALSE;
621  }
622  if (h->Typ() != STRING_CMD &&
623  h->Typ() != INT_CMD)
624  {
625  WerrorS("Need string or int argument to set option value");
626  return TRUE;
627  }
628  const char* errormsg;
629  if (h->Typ() == INT_CMD)
630  {
631  if (feOptSpec[opt].type == feOptString)
632  {
633  Werror("Need string argument to set value of option %s", sys_cmd);
634  return TRUE;
635  }
636  errormsg = feSetOptValue(opt, (int)((long) h->Data()));
637  if (errormsg != NULL)
638  Werror("Option '--%s=%d' %s", sys_cmd, (int) ((long)h->Data()), errormsg);
639  }
640  else
641  {
642  errormsg = feSetOptValue(opt, (char*) h->Data());
643  if (errormsg != NULL)
644  Werror("Option '--%s=%s' %s", sys_cmd, (char*) h->Data(), errormsg);
645  }
646  if (errormsg != NULL) return TRUE;
647  return FALSE;
648  }
649  else
650  /*==================== HC ==================================*/
651  if (strcmp(sys_cmd,"HC")==0)
652  {
653  res->rtyp=INT_CMD;
654  res->data=(void *)(long) HCord;
655  return FALSE;
656  }
657  else
658  /*==================== random ==================================*/
659  if(strcmp(sys_cmd,"random")==0)
660  {
661  const short t[]={1,INT_CMD};
662  if (h!=NULL)
663  {
664  if (iiCheckTypes(h,t,1))
665  {
666  siRandomStart=(int)((long)h->Data());
669  return FALSE;
670  }
671  else
672  {
673  return TRUE;
674  }
675  }
676  res->rtyp=INT_CMD;
677  res->data=(void*)(long) siSeed;
678  return FALSE;
679  }
680  else
681  /*==================== std_syz =================*/
682  if (strcmp(sys_cmd, "std_syz") == 0)
683  {
684  ideal i1;
685  int i2;
686  if ((h!=NULL) && (h->Typ()==MODUL_CMD))
687  {
688  i1=(ideal)h->CopyD();
689  h=h->next;
690  }
691  else return TRUE;
692  if ((h!=NULL) && (h->Typ()==INT_CMD))
693  {
694  i2=(int)((long)h->Data());
695  }
696  else return TRUE;
697  res->rtyp=MODUL_CMD;
698  res->data=idXXX(i1,i2);
699  return FALSE;
700  }
701  else
702  /*======================= demon_list =====================*/
703  if (strcmp(sys_cmd,"denom_list")==0)
704  {
705  res->rtyp=LIST_CMD;
706  extern lists get_denom_list();
707  res->data=(lists)get_denom_list();
708  return FALSE;
709  }
710  else
711  /*==================== complexNearZero ======================*/
712  if(strcmp(sys_cmd,"complexNearZero")==0)
713  {
714  const short t[]={2,NUMBER_CMD,INT_CMD};
715  if (iiCheckTypes(h,t,1))
716  {
717  if ( !rField_is_long_C(currRing) )
718  {
719  WerrorS( "unsupported ground field!");
720  return TRUE;
721  }
722  else
723  {
724  res->rtyp=INT_CMD;
725  res->data=(void*)complexNearZero((gmp_complex*)h->Data(),
726  (int)((long)(h->next->Data())));
727  return FALSE;
728  }
729  }
730  else
731  {
732  return TRUE;
733  }
734  }
735  else
736  /*==================== getPrecDigits ======================*/
737  if(strcmp(sys_cmd,"getPrecDigits")==0)
738  {
739  if ( (currRing==NULL)
741  {
742  WerrorS( "unsupported ground field!");
743  return TRUE;
744  }
745  res->rtyp=INT_CMD;
746  res->data=(void*)(long)gmp_output_digits;
747  //if (gmp_output_digits!=getGMPFloatDigits())
748  //{ Print("%d, %d\n",getGMPFloatDigits(),gmp_output_digits);}
749  return FALSE;
750  }
751  else
752  /*==================== lduDecomp ======================*/
753  if(strcmp(sys_cmd, "lduDecomp")==0)
754  {
755  const short t[]={1,MATRIX_CMD};
756  if (iiCheckTypes(h,t,1))
757  {
758  matrix aMat = (matrix)h->Data();
759  matrix pMat; matrix lMat; matrix dMat; matrix uMat;
760  poly l; poly u; poly prodLU;
761  lduDecomp(aMat, pMat, lMat, dMat, uMat, l, u, prodLU);
763  L->Init(7);
764  L->m[0].rtyp = MATRIX_CMD; L->m[0].data=(void*)pMat;
765  L->m[1].rtyp = MATRIX_CMD; L->m[1].data=(void*)lMat;
766  L->m[2].rtyp = MATRIX_CMD; L->m[2].data=(void*)dMat;
767  L->m[3].rtyp = MATRIX_CMD; L->m[3].data=(void*)uMat;
768  L->m[4].rtyp = POLY_CMD; L->m[4].data=(void*)l;
769  L->m[5].rtyp = POLY_CMD; L->m[5].data=(void*)u;
770  L->m[6].rtyp = POLY_CMD; L->m[6].data=(void*)prodLU;
771  res->rtyp = LIST_CMD;
772  res->data = (char *)L;
773  return FALSE;
774  }
775  else
776  {
777  return TRUE;
778  }
779  }
780  else
781  /*==================== lduSolve ======================*/
782  if(strcmp(sys_cmd, "lduSolve")==0)
783  {
784  /* for solving a linear equation system A * x = b, via the
785  given LDU-decomposition of the matrix A;
786  There is one valid parametrisation:
787  1) exactly eight arguments P, L, D, U, l, u, lTimesU, b;
788  P, L, D, and U realise the LDU-decomposition of A, that is,
789  P * A = L * D^(-1) * U, and P, L, D, and U satisfy the
790  properties decribed in method 'luSolveViaLDUDecomp' in
791  linearAlgebra.h; see there;
792  l, u, and lTimesU are as described in the same location;
793  b is the right-hand side vector of the linear equation system;
794  The method will return a list of either 1 entry or three entries:
795  1) [0] if there is no solution to the system;
796  2) [1, x, H] if there is at least one solution;
797  x is any solution of the given linear system,
798  H is the matrix with column vectors spanning the homogeneous
799  solution space.
800  The method produces an error if matrix and vector sizes do not
801  fit. */
803  if (!iiCheckTypes(h,t,1))
804  {
805  return TRUE;
806  }
808  {
809  WerrorS("field required");
810  return TRUE;
811  }
812  matrix pMat = (matrix)h->Data();
813  matrix lMat = (matrix)h->next->Data();
814  matrix dMat = (matrix)h->next->next->Data();
815  matrix uMat = (matrix)h->next->next->next->Data();
816  poly l = (poly) h->next->next->next->next->Data();
817  poly u = (poly) h->next->next->next->next->next->Data();
818  poly lTimesU = (poly) h->next->next->next->next->next->next->Data();
819  matrix bVec = (matrix)h->next->next->next->next->next->next->next->Data();
820  matrix xVec; int solvable; matrix homogSolSpace;
821  if (pMat->rows() != pMat->cols())
822  {
823  Werror("first matrix (%d x %d) is not quadratic",
824  pMat->rows(), pMat->cols());
825  return TRUE;
826  }
827  if (lMat->rows() != lMat->cols())
828  {
829  Werror("second matrix (%d x %d) is not quadratic",
830  lMat->rows(), lMat->cols());
831  return TRUE;
832  }
833  if (dMat->rows() != dMat->cols())
834  {
835  Werror("third matrix (%d x %d) is not quadratic",
836  dMat->rows(), dMat->cols());
837  return TRUE;
838  }
839  if (dMat->cols() != uMat->rows())
840  {
841  Werror("third matrix (%d x %d) and fourth matrix (%d x %d) %s",
842  dMat->rows(), dMat->cols(), uMat->rows(), uMat->cols(),
843  "do not t");
844  return TRUE;
845  }
846  if (uMat->rows() != bVec->rows())
847  {
848  Werror("fourth matrix (%d x %d) and vector (%d x 1) do not fit",
849  uMat->rows(), uMat->cols(), bVec->rows());
850  return TRUE;
851  }
852  solvable = luSolveViaLDUDecomp(pMat, lMat, dMat, uMat, l, u, lTimesU,
853  bVec, xVec, homogSolSpace);
854 
855  /* build the return structure; a list with either one or
856  three entries */
858  if (solvable)
859  {
860  ll->Init(3);
861  ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)solvable;
862  ll->m[1].rtyp=MATRIX_CMD; ll->m[1].data=(void *)xVec;
863  ll->m[2].rtyp=MATRIX_CMD; ll->m[2].data=(void *)homogSolSpace;
864  }
865  else
866  {
867  ll->Init(1);
868  ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)solvable;
869  }
870  res->rtyp = LIST_CMD;
871  res->data=(char*)ll;
872  return FALSE;
873  }
874  else
875  /*==== countedref: reference and shared ====*/
876  if (strcmp(sys_cmd, "shared") == 0)
877  {
878  #ifndef SI_COUNTEDREF_AUTOLOAD
879  void countedref_shared_load();
881  #endif
882  res->rtyp = NONE;
883  return FALSE;
884  }
885  else if (strcmp(sys_cmd, "reference") == 0)
886  {
887  #ifndef SI_COUNTEDREF_AUTOLOAD
890  #endif
891  res->rtyp = NONE;
892  return FALSE;
893  }
894  else
895 /*==================== semaphore =================*/
896 #ifdef HAVE_SIMPLEIPC
897  if (strcmp(sys_cmd,"semaphore")==0)
898  {
899  if((h!=NULL) && (h->Typ()==STRING_CMD) && (h->next!=NULL) && (h->next->Typ()==INT_CMD))
900  {
901  int v=1;
902  if ((h->next->next!=NULL)&& (h->next->next->Typ()==INT_CMD))
903  v=(int)(long)h->next->next->Data();
904  res->data=(char *)(long)simpleipc_cmd((char *)h->Data(),(int)(long)h->next->Data(),v);
905  res->rtyp=INT_CMD;
906  return FALSE;
907  }
908  else
909  {
910  WerrorS("Usage: system(\"semaphore\",<cmd>,int)");
911  return TRUE;
912  }
913  }
914  else
915 #endif
916 /*==================== reserved port =================*/
917  if (strcmp(sys_cmd,"reserve")==0)
918  {
919  int ssiReservePort(int clients);
920  const short t[]={1,INT_CMD};
921  if (iiCheckTypes(h,t,1))
922  {
923  res->rtyp=INT_CMD;
924  int p=ssiReservePort((int)(long)h->Data());
925  res->data=(void*)(long)p;
926  return (p==0);
927  }
928  return TRUE;
929  }
930  else
931 /*==================== reserved link =================*/
932  if (strcmp(sys_cmd,"reservedLink")==0)
933  {
934  res->rtyp=LINK_CMD;
936  res->data=(void*)p;
937  return (p==NULL);
938  }
939  else
940 /*==================== install newstruct =================*/
941  if (strcmp(sys_cmd,"install")==0)
942  {
943  const short t[]={4,STRING_CMD,STRING_CMD,PROC_CMD,INT_CMD};
944  if (iiCheckTypes(h,t,1))
945  {
946  return newstruct_set_proc((char*)h->Data(),(char*)h->next->Data(),
947  (int)(long)h->next->next->next->Data(),
948  (procinfov)h->next->next->Data());
949  }
950  return TRUE;
951  }
952  else
953 /*==================== newstruct =================*/
954  if (strcmp(sys_cmd,"newstruct")==0)
955  {
956  const short t[]={1,STRING_CMD};
957  if (iiCheckTypes(h,t,1))
958  {
959  int id=0;
960  char *n=(char*)h->Data();
961  blackboxIsCmd(n,id);
962  if (id>0)
963  {
964  blackbox *bb=getBlackboxStuff(id);
965  if (BB_LIKE_LIST(bb))
966  {
967  newstruct_desc desc=(newstruct_desc)bb->data;
968  newstructShow(desc);
969  return FALSE;
970  }
971  else Werror("'%s' is not a newstruct",n);
972  }
973  else Werror("'%s' is not a blackbox object",n);
974  }
975  return TRUE;
976  }
977  else
978 /*==================== blackbox =================*/
979  if (strcmp(sys_cmd,"blackbox")==0)
980  {
982  return FALSE;
983  }
984  else
985  /*================= absBiFact ======================*/
986  #ifdef HAVE_NTL
987  if (strcmp(sys_cmd, "absFact") == 0)
988  {
989  const short t[]={1,POLY_CMD};
990  if (iiCheckTypes(h,t,1)
991  && (currRing!=NULL)
992  && (getCoeffType(currRing->cf)==n_transExt))
993  {
994  res->rtyp=LIST_CMD;
995  intvec *v=NULL;
996  ideal mipos= NULL;
997  int n= 0;
998  ideal f=singclap_absFactorize((poly)(h->Data()), mipos, &v, n, currRing);
999  if (f==NULL) return TRUE;
1000  ivTest(v);
1002  l->Init(4);
1003  l->m[0].rtyp=IDEAL_CMD;
1004  l->m[0].data=(void *)f;
1005  l->m[1].rtyp=INTVEC_CMD;
1006  l->m[1].data=(void *)v;
1007  l->m[2].rtyp=IDEAL_CMD;
1008  l->m[2].data=(void*) mipos;
1009  l->m[3].rtyp=INT_CMD;
1010  l->m[3].data=(void*) (long) n;
1011  res->data=(void *)l;
1012  return FALSE;
1013  }
1014  else return TRUE;
1015  }
1016  else
1017  #endif
1018  /* =================== LLL via NTL ==============================*/
1019  #ifdef HAVE_NTL
1020  if (strcmp(sys_cmd, "LLL") == 0)
1021  {
1022  if (h!=NULL)
1023  {
1024  res->rtyp=h->Typ();
1025  if (h->Typ()==MATRIX_CMD)
1026  {
1027  res->data=(char *)singntl_LLL((matrix)h->Data(), currRing);
1028  return FALSE;
1029  }
1030  else if (h->Typ()==INTMAT_CMD)
1031  {
1032  res->data=(char *)singntl_LLL((intvec*)h->Data());
1033  return FALSE;
1034  }
1035  else return TRUE;
1036  }
1037  else return TRUE;
1038  }
1039  else
1040  #endif
1041  /* =================== LLL via Flint ==============================*/
1042  #ifdef HAVE_FLINT
1043  #if __FLINT_RELEASE >= 20500
1044  if (strcmp(sys_cmd, "LLL_Flint") == 0)
1045  {
1046  if (h!=NULL)
1047  {
1048  if(h->next == NULL)
1049  {
1050  res->rtyp=h->Typ();
1051  if (h->Typ()==BIGINTMAT_CMD)
1052  {
1053  res->data=(char *)singflint_LLL((bigintmat*)h->Data(), NULL);
1054  return FALSE;
1055  }
1056  else if (h->Typ()==INTMAT_CMD)
1057  {
1058  res->data=(char *)singflint_LLL((intvec*)h->Data(), NULL);
1059  return FALSE;
1060  }
1061  else return TRUE;
1062  }
1063  if(h->next->Typ()!= INT_CMD)
1064  {
1065  WerrorS("matrix,int or bigint,int expected");
1066  return TRUE;
1067  }
1068  if(h->next->Typ()== INT_CMD)
1069  {
1070  if(((int)((long)(h->next->Data())) != 0) && (int)((long)(h->next->Data()) != 1))
1071  {
1072  WerrorS("int is different from 0, 1");
1073  return TRUE;
1074  }
1075  res->rtyp=h->Typ();
1076  if((long)(h->next->Data()) == 0)
1077  {
1078  if (h->Typ()==BIGINTMAT_CMD)
1079  {
1080  res->data=(char *)singflint_LLL((bigintmat*)h->Data(), NULL);
1081  return FALSE;
1082  }
1083  else if (h->Typ()==INTMAT_CMD)
1084  {
1085  res->data=(char *)singflint_LLL((intvec*)h->Data(), NULL);
1086  return FALSE;
1087  }
1088  else return TRUE;
1089  }
1090  // This will give also the transformation matrix U s.t. res = U * m
1091  if((long)(h->next->Data()) == 1)
1092  {
1093  if (h->Typ()==BIGINTMAT_CMD)
1094  {
1095  bigintmat* m = (bigintmat*)h->Data();
1096  bigintmat* T = new bigintmat(m->rows(),m->rows(),m->basecoeffs());
1097  for(int i = 1; i<=m->rows(); i++)
1098  {
1099  n_Delete(&(BIMATELEM(*T,i,i)),T->basecoeffs());
1100  BIMATELEM(*T,i,i)=n_Init(1, T->basecoeffs());
1101  }
1102  m = singflint_LLL(m,T);
1104  L->Init(2);
1105  L->m[0].rtyp = BIGINTMAT_CMD; L->m[0].data = (void*)m;
1106  L->m[1].rtyp = BIGINTMAT_CMD; L->m[1].data = (void*)T;
1107  res->data=L;
1108  res->rtyp=LIST_CMD;
1109  return FALSE;
1110  }
1111  else if (h->Typ()==INTMAT_CMD)
1112  {
1113  intvec* m = (intvec*)h->Data();
1114  intvec* T = new intvec(m->rows(),m->rows(),(int)0);
1115  for(int i = 1; i<=m->rows(); i++)
1116  IMATELEM(*T,i,i)=1;
1117  m = singflint_LLL(m,T);
1119  L->Init(2);
1120  L->m[0].rtyp = INTMAT_CMD; L->m[0].data = (void*)m;
1121  L->m[1].rtyp = INTMAT_CMD; L->m[1].data = (void*)T;
1122  res->data=L;
1123  res->rtyp=LIST_CMD;
1124  return FALSE;
1125  }
1126  else return TRUE;
1127  }
1128  }
1129 
1130  }
1131  else return TRUE;
1132  }
1133  else
1134  #endif
1135  #endif
1136  /*==================== shift-test for freeGB =================*/
1137  #ifdef HAVE_SHIFTBBA
1138  if (strcmp(sys_cmd, "stest") == 0)
1139  {
1140  const short t[]={4,POLY_CMD,INT_CMD,INT_CMD,INT_CMD};
1141  if (iiCheckTypes(h,t,1))
1142  {
1143  poly p=(poly)h->CopyD();
1144  h=h->next;
1145  int sh=(int)((long)(h->Data()));
1146  h=h->next;
1147  int uptodeg=(int)((long)(h->Data()));
1148  h=h->next;
1149  int lVblock=(int)((long)(h->Data()));
1150  if (sh<0)
1151  {
1152  WerrorS("negative shift for pLPshift");
1153  return TRUE;
1154  }
1155  int L = pLastVblock(p,lVblock);
1156  if (L+sh > uptodeg)
1157  {
1158  WerrorS("pLPshift: too big shift requested\n");
1159  return TRUE;
1160  }
1161  res->data = p_LPshift(p,sh,uptodeg,lVblock,currRing);
1162  res->rtyp = POLY_CMD;
1163  return FALSE;
1164  }
1165  else return TRUE;
1166  }
1167  else
1168  #endif
1169  /*==================== block-test for freeGB =================*/
1170  #ifdef HAVE_SHIFTBBA
1171  if (strcmp(sys_cmd, "btest") == 0)
1172  {
1173  const short t[]={2,POLY_CMD,INT_CMD};
1174  if (iiCheckTypes(h,t,1))
1175  {
1176  poly p=(poly)h->CopyD();
1177  h=h->next;
1178  int lV=(int)((long)(h->Data()));
1179  res->rtyp = INT_CMD;
1180  res->data = (void*)(long)pLastVblock(p, lV);
1181  return FALSE;
1182  }
1183  else return TRUE;
1184  }
1185  else
1186  #endif
1187  /*==================== shrink-test for freeGB =================*/
1188  #ifdef HAVE_SHIFTBBA
1189  if (strcmp(sys_cmd, "shrinktest") == 0)
1190  {
1191  const short t[]={2,POLY_CMD,INT_CMD};
1192  if (iiCheckTypes(h,t,1))
1193  {
1194  poly p=(poly)h->Data();
1195  h=h->next;
1196  int lV=(int)((long)(h->Data()));
1197  res->rtyp = POLY_CMD;
1198  // res->data = p_mShrink(p, lV, currRing);
1199  // kStrategy strat=new skStrategy;
1200  // strat->tailRing = currRing;
1201  res->data = p_Shrink(p, lV, currRing);
1202  return FALSE;
1203  }
1204  else return TRUE;
1205  }
1206  else
1207  #endif
1208  /*==================== pcv ==================================*/
1209  #ifdef HAVE_PCV
1210  if(strcmp(sys_cmd,"pcvLAddL")==0)
1211  {
1212  return pcvLAddL(res,h);
1213  }
1214  else
1215  if(strcmp(sys_cmd,"pcvPMulL")==0)
1216  {
1217  return pcvPMulL(res,h);
1218  }
1219  else
1220  if(strcmp(sys_cmd,"pcvMinDeg")==0)
1221  {
1222  return pcvMinDeg(res,h);
1223  }
1224  else
1225  if(strcmp(sys_cmd,"pcvP2CV")==0)
1226  {
1227  return pcvP2CV(res,h);
1228  }
1229  else
1230  if(strcmp(sys_cmd,"pcvCV2P")==0)
1231  {
1232  return pcvCV2P(res,h);
1233  }
1234  else
1235  if(strcmp(sys_cmd,"pcvDim")==0)
1236  {
1237  return pcvDim(res,h);
1238  }
1239  else
1240  if(strcmp(sys_cmd,"pcvBasis")==0)
1241  {
1242  return pcvBasis(res,h);
1243  }
1244  else
1245  #endif
1246  /*==================== hessenberg/eigenvalues ==================================*/
1247  #ifdef HAVE_EIGENVAL
1248  if(strcmp(sys_cmd,"hessenberg")==0)
1249  {
1250  return evHessenberg(res,h);
1251  }
1252  else
1253  #endif
1254  /*==================== eigenvalues ==================================*/
1255  #ifdef HAVE_EIGENVAL
1256  if(strcmp(sys_cmd,"eigenvals")==0)
1257  {
1258  return evEigenvals(res,h);
1259  }
1260  else
1261  #endif
1262  /*==================== rowelim ==================================*/
1263  #ifdef HAVE_EIGENVAL
1264  if(strcmp(sys_cmd,"rowelim")==0)
1265  {
1266  return evRowElim(res,h);
1267  }
1268  else
1269  #endif
1270  /*==================== rowcolswap ==================================*/
1271  #ifdef HAVE_EIGENVAL
1272  if(strcmp(sys_cmd,"rowcolswap")==0)
1273  {
1274  return evSwap(res,h);
1275  }
1276  else
1277  #endif
1278  /*==================== Gauss-Manin system ==================================*/
1279  #ifdef HAVE_GMS
1280  if(strcmp(sys_cmd,"gmsnf")==0)
1281  {
1282  return gmsNF(res,h);
1283  }
1284  else
1285  #endif
1286  /*==================== contributors =============================*/
1287  if(strcmp(sys_cmd,"contributors") == 0)
1288  {
1289  res->rtyp=STRING_CMD;
1290  res->data=(void *)omStrDup(
1291  "Olaf Bachmann, Michael Brickenstein, Hubert Grassmann, Kai Krueger, Victor Levandovskyy, Wolfgang Neumann, Thomas Nuessler, Wilfred Pohl, Jens Schmidt, Mathias Schulze, Thomas Siebert, Ruediger Stobbe, Moritz Wenk, Tim Wichmann");
1292  return FALSE;
1293  }
1294  else
1295  /*==================== spectrum =============================*/
1296  #ifdef HAVE_SPECTRUM
1297  if(strcmp(sys_cmd,"spectrum") == 0)
1298  {
1299  if ((h==NULL) || (h->Typ()!=POLY_CMD))
1300  {
1301  WerrorS("poly expected");
1302  return TRUE;
1303  }
1304  if (h->next==NULL)
1305  return spectrumProc(res,h);
1306  if (h->next->Typ()!=INT_CMD)
1307  {
1308  WerrorS("poly,int expected");
1309  return TRUE;
1310  }
1311  if(((long)h->next->Data())==1L)
1312  return spectrumfProc(res,h);
1313  return spectrumProc(res,h);
1314  }
1315  else
1316  /*==================== semic =============================*/
1317  if(strcmp(sys_cmd,"semic") == 0)
1318  {
1319  if ((h->next!=NULL)
1320  && (h->Typ()==LIST_CMD)
1321  && (h->next->Typ()==LIST_CMD))
1322  {
1323  if (h->next->next==NULL)
1324  return semicProc(res,h,h->next);
1325  else if (h->next->next->Typ()==INT_CMD)
1326  return semicProc3(res,h,h->next,h->next->next);
1327  }
1328  return TRUE;
1329  }
1330  else
1331  /*==================== spadd =============================*/
1332  if(strcmp(sys_cmd,"spadd") == 0)
1333  {
1334  const short t[]={2,LIST_CMD,LIST_CMD};
1335  if (iiCheckTypes(h,t,1))
1336  {
1337  return spaddProc(res,h,h->next);
1338  }
1339  return TRUE;
1340  }
1341  else
1342  /*==================== spmul =============================*/
1343  if(strcmp(sys_cmd,"spmul") == 0)
1344  {
1345  const short t[]={2,LIST_CMD,INT_CMD};
1346  if (iiCheckTypes(h,t,1))
1347  {
1348  return spmulProc(res,h,h->next);
1349  }
1350  return TRUE;
1351  }
1352  else
1353  #endif
1354 /*==================== tensorModuleMult ========================= */
1355  #define HAVE_SHEAFCOH_TRICKS 1
1356 
1357  #ifdef HAVE_SHEAFCOH_TRICKS
1358  if(strcmp(sys_cmd,"tensorModuleMult")==0)
1359  {
1360  const short t[]={2,INT_CMD,MODUL_CMD};
1361  // WarnS("tensorModuleMult!");
1362  if (iiCheckTypes(h,t,1))
1363  {
1364  int m = (int)( (long)h->Data() );
1365  ideal M = (ideal)h->next->Data();
1366  res->rtyp=MODUL_CMD;
1367  res->data=(void *)id_TensorModuleMult(m, M, currRing);
1368  return FALSE;
1369  }
1370  return TRUE;
1371  }
1372  else
1373  #endif
1374  /*==================== twostd =================*/
1375  #ifdef HAVE_PLURAL
1376  if (strcmp(sys_cmd, "twostd") == 0)
1377  {
1378  ideal I;
1379  if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
1380  {
1381  I=(ideal)h->CopyD();
1382  res->rtyp=IDEAL_CMD;
1383  if (rIsPluralRing(currRing)) res->data=twostd(I);
1384  else res->data=I;
1386  setFlag(res,FLAG_STD);
1387  }
1388  else return TRUE;
1389  return FALSE;
1390  }
1391  else
1392  #endif
1393  /*==================== lie bracket =================*/
1394  #ifdef HAVE_PLURAL
1395  if (strcmp(sys_cmd, "bracket") == 0)
1396  {
1397  const short t[]={2,POLY_CMD,POLY_CMD};
1398  if (iiCheckTypes(h,t,1))
1399  {
1400  poly p=(poly)h->CopyD();
1401  h=h->next;
1402  poly q=(poly)h->Data();
1403  res->rtyp=POLY_CMD;
1405  return FALSE;
1406  }
1407  return TRUE;
1408  }
1409  else
1410  #endif
1411  /*==================== env ==================================*/
1412  #ifdef HAVE_PLURAL
1413  if (strcmp(sys_cmd, "env")==0)
1414  {
1415  if ((h!=NULL) && (h->Typ()==RING_CMD))
1416  {
1417  ring r = (ring)h->Data();
1418  res->data = rEnvelope(r);
1419  res->rtyp = RING_CMD;
1420  return FALSE;
1421  }
1422  else
1423  {
1424  WerrorS("`system(\"env\",<ring>)` expected");
1425  return TRUE;
1426  }
1427  }
1428  else
1429  #endif
1430 /* ============ opp ======================== */
1431  #ifdef HAVE_PLURAL
1432  if (strcmp(sys_cmd, "opp")==0)
1433  {
1434  if ((h!=NULL) && (h->Typ()==RING_CMD))
1435  {
1436  ring r=(ring)h->Data();
1437  res->data=rOpposite(r);
1438  res->rtyp=RING_CMD;
1439  return FALSE;
1440  }
1441  else
1442  {
1443  WerrorS("`system(\"opp\",<ring>)` expected");
1444  return TRUE;
1445  }
1446  }
1447  else
1448  #endif
1449  /*==================== oppose ==================================*/
1450  #ifdef HAVE_PLURAL
1451  if (strcmp(sys_cmd, "oppose")==0)
1452  {
1453  if ((h!=NULL) && (h->Typ()==RING_CMD)
1454  && (h->next!= NULL))
1455  {
1456  ring Rop = (ring)h->Data();
1457  h = h->next;
1458  idhdl w;
1459  if ((w=Rop->idroot->get(h->Name(),myynest))!=NULL)
1460  {
1461  poly p = (poly)IDDATA(w);
1462  res->data = pOppose(Rop, p, currRing); // into CurrRing?
1463  res->rtyp = POLY_CMD;
1464  return FALSE;
1465  }
1466  }
1467  else
1468  {
1469  WerrorS("`system(\"oppose\",<ring>,<poly>)` expected");
1470  return TRUE;
1471  }
1472  }
1473  else
1474  #endif
1475  /*==================== freeGB, twosided GB in free algebra =================*/
1476  #ifdef HAVE_PLURAL
1477  #ifdef HAVE_SHIFTBBA
1478  if (strcmp(sys_cmd, "freegb") == 0)
1479  {
1480  const short t[]={3,IDEAL_CMD,INT_CMD,INT_CMD};
1481  if (iiCheckTypes(h,t,1))
1482  {
1483  ideal I=(ideal)h->CopyD();
1484  h=h->next;
1485  int uptodeg=(int)((long)(h->Data()));
1486  h=h->next;
1487  int lVblock=(int)((long)(h->Data()));
1488  res->data = freegb(I,uptodeg,lVblock);
1489  if (res->data == NULL)
1490  {
1491  /* that is there were input errors */
1492  res->data = I;
1493  }
1494  res->rtyp = IDEAL_CMD;
1495  return FALSE;
1496  }
1497  else return TRUE;
1498  }
1499  else
1500  #endif /*SHIFTBBA*/
1501  #endif /*PLURAL*/
1502  /*==================== walk stuff =================*/
1503  /*==================== walkNextWeight =================*/
1504  #ifdef HAVE_WALK
1505  #ifdef OWNW
1506  if (strcmp(sys_cmd, "walkNextWeight") == 0)
1507  {
1508  const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
1509  if (!iiCheckTypes(h,t,1)) return TRUE;
1510  if (((intvec*) h->Data())->length() != currRing->N ||
1511  ((intvec*) h->next->Data())->length() != currRing->N)
1512  {
1513  Werror("system(\"walkNextWeight\" ...) intvecs not of length %d\n",
1514  currRing->N);
1515  return TRUE;
1516  }
1517  res->data = (void*) walkNextWeight(((intvec*) h->Data()),
1518  ((intvec*) h->next->Data()),
1519  (ideal) h->next->next->Data());
1520  if (res->data == NULL || res->data == (void*) 1L)
1521  {
1522  res->rtyp = INT_CMD;
1523  }
1524  else
1525  {
1526  res->rtyp = INTVEC_CMD;
1527  }
1528  return FALSE;
1529  }
1530  else
1531  #endif
1532  #endif
1533  /*==================== walkNextWeight =================*/
1534  #ifdef HAVE_WALK
1535  #ifdef OWNW
1536  if (strcmp(sys_cmd, "walkInitials") == 0)
1537  {
1538  if (h == NULL || h->Typ() != IDEAL_CMD)
1539  {
1540  WerrorS("system(\"walkInitials\", ideal) expected");
1541  return TRUE;
1542  }
1543  res->data = (void*) walkInitials((ideal) h->Data());
1544  res->rtyp = IDEAL_CMD;
1545  return FALSE;
1546  }
1547  else
1548  #endif
1549  #endif
1550  /*==================== walkAddIntVec =================*/
1551  #ifdef HAVE_WALK
1552  #ifdef WAIV
1553  if (strcmp(sys_cmd, "walkAddIntVec") == 0)
1554  {
1555  const short t[]={2,INTVEC_CMD,INTVEC_CMD};
1556  if (!iiCheckTypes(h,t,1)) return TRUE;
1557  intvec* arg1 = (intvec*) h->Data();
1558  intvec* arg2 = (intvec*) h->next->Data();
1559  res->data = (intvec*) walkAddIntVec(arg1, arg2);
1560  res->rtyp = INTVEC_CMD;
1561  return FALSE;
1562  }
1563  else
1564  #endif
1565  #endif
1566  /*==================== MwalkNextWeight =================*/
1567  #ifdef HAVE_WALK
1568  #ifdef MwaklNextWeight
1569  if (strcmp(sys_cmd, "MwalkNextWeight") == 0)
1570  {
1571  const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
1572  if (!iiCheckTypes(h,t,1)) return TRUE;
1573  if (((intvec*) h->Data())->length() != currRing->N ||
1574  ((intvec*) h->next->Data())->length() != currRing->N)
1575  {
1576  Werror("system(\"MwalkNextWeight\" ...) intvecs not of length %d\n",
1577  currRing->N);
1578  return TRUE;
1579  }
1580  intvec* arg1 = (intvec*) h->Data();
1581  intvec* arg2 = (intvec*) h->next->Data();
1582  ideal arg3 = (ideal) h->next->next->Data();
1583  intvec* result = (intvec*) MwalkNextWeight(arg1, arg2, arg3);
1584  res->rtyp = INTVEC_CMD;
1585  res->data = result;
1586  return FALSE;
1587  }
1588  else
1589  #endif //MWalkNextWeight
1590  #endif
1591  /*==================== Mivdp =================*/
1592  #ifdef HAVE_WALK
1593  if(strcmp(sys_cmd, "Mivdp") == 0)
1594  {
1595  if (h == NULL || h->Typ() != INT_CMD)
1596  {
1597  WerrorS("system(\"Mivdp\", int) expected");
1598  return TRUE;
1599  }
1600  if ((int) ((long)(h->Data())) != currRing->N)
1601  {
1602  Werror("system(\"Mivdp\" ...) intvecs not of length %d\n",
1603  currRing->N);
1604  return TRUE;
1605  }
1606  int arg1 = (int) ((long)(h->Data()));
1607  intvec* result = (intvec*) Mivdp(arg1);
1608  res->rtyp = INTVEC_CMD;
1609  res->data = result;
1610  return FALSE;
1611  }
1612  else
1613  #endif
1614  /*==================== Mivlp =================*/
1615  #ifdef HAVE_WALK
1616  if(strcmp(sys_cmd, "Mivlp") == 0)
1617  {
1618  if (h == NULL || h->Typ() != INT_CMD)
1619  {
1620  WerrorS("system(\"Mivlp\", int) expected");
1621  return TRUE;
1622  }
1623  if ((int) ((long)(h->Data())) != currRing->N)
1624  {
1625  Werror("system(\"Mivlp\" ...) intvecs not of length %d\n",
1626  currRing->N);
1627  return TRUE;
1628  }
1629  int arg1 = (int) ((long)(h->Data()));
1630  intvec* result = (intvec*) Mivlp(arg1);
1631  res->rtyp = INTVEC_CMD;
1632  res->data = result;
1633  return FALSE;
1634  }
1635  else
1636  #endif
1637  /*==================== MpDiv =================*/
1638  #ifdef HAVE_WALK
1639  #ifdef MpDiv
1640  if(strcmp(sys_cmd, "MpDiv") == 0)
1641  {
1642  const short t[]={2,POLY_CMD,POLY_CMD};
1643  if (!iiCheckTypes(h,t,1)) return TRUE;
1644  poly arg1 = (poly) h->Data();
1645  poly arg2 = (poly) h->next->Data();
1646  poly result = MpDiv(arg1, arg2);
1647  res->rtyp = POLY_CMD;
1648  res->data = result;
1649  return FALSE;
1650  }
1651  else
1652  #endif
1653  #endif
1654  /*==================== MpMult =================*/
1655  #ifdef HAVE_WALK
1656  #ifdef MpMult
1657  if(strcmp(sys_cmd, "MpMult") == 0)
1658  {
1659  const short t[]={2,POLY_CMD,POLY_CMD};
1660  if (!iiCheckTypes(h,t,1)) return TRUE;
1661  poly arg1 = (poly) h->Data();
1662  poly arg2 = (poly) h->next->Data();
1663  poly result = MpMult(arg1, arg2);
1664  res->rtyp = POLY_CMD;
1665  res->data = result;
1666  return FALSE;
1667  }
1668  else
1669  #endif
1670  #endif
1671  /*==================== MivSame =================*/
1672  #ifdef HAVE_WALK
1673  if (strcmp(sys_cmd, "MivSame") == 0)
1674  {
1675  const short t[]={2,INTVEC_CMD,INTVEC_CMD};
1676  if (!iiCheckTypes(h,t,1)) return TRUE;
1677  /*
1678  if (((intvec*) h->Data())->length() != currRing->N ||
1679  ((intvec*) h->next->Data())->length() != currRing->N)
1680  {
1681  Werror("system(\"MivSame\" ...) intvecs not of length %d\n",
1682  currRing->N);
1683  return TRUE;
1684  }
1685  */
1686  intvec* arg1 = (intvec*) h->Data();
1687  intvec* arg2 = (intvec*) h->next->Data();
1688  /*
1689  poly result = (poly) MivSame(arg1, arg2);
1690  res->rtyp = POLY_CMD;
1691  res->data = (poly) result;
1692  */
1693  res->rtyp = INT_CMD;
1694  res->data = (void*)(long) MivSame(arg1, arg2);
1695  return FALSE;
1696  }
1697  else
1698  #endif
1699  /*==================== M3ivSame =================*/
1700  #ifdef HAVE_WALK
1701  if (strcmp(sys_cmd, "M3ivSame") == 0)
1702  {
1703  const short t[]={3,INTVEC_CMD,INTVEC_CMD,INTVEC_CMD};
1704  if (!iiCheckTypes(h,t,1)) return TRUE;
1705  /*
1706  if (((intvec*) h->Data())->length() != currRing->N ||
1707  ((intvec*) h->next->Data())->length() != currRing->N ||
1708  ((intvec*) h->next->next->Data())->length() != currRing->N )
1709  {
1710  Werror("system(\"M3ivSame\" ...) intvecs not of length %d\n",
1711  currRing->N);
1712  return TRUE;
1713  }
1714  */
1715  intvec* arg1 = (intvec*) h->Data();
1716  intvec* arg2 = (intvec*) h->next->Data();
1717  intvec* arg3 = (intvec*) h->next->next->Data();
1718  /*
1719  poly result = (poly) M3ivSame(arg1, arg2, arg3);
1720  res->rtyp = POLY_CMD;
1721  res->data = (poly) result;
1722  */
1723  res->rtyp = INT_CMD;
1724  res->data = (void*)(long) M3ivSame(arg1, arg2, arg3);
1725  return FALSE;
1726  }
1727  else
1728  #endif
1729  /*==================== MwalkInitialForm =================*/
1730  #ifdef HAVE_WALK
1731  if(strcmp(sys_cmd, "MwalkInitialForm") == 0)
1732  {
1733  const short t[]={2,IDEAL_CMD,INTVEC_CMD};
1734  if (!iiCheckTypes(h,t,1)) return TRUE;
1735  if(((intvec*) h->next->Data())->length() != currRing->N)
1736  {
1737  Werror("system \"MwalkInitialForm\"...) intvec not of length %d\n",
1738  currRing->N);
1739  return TRUE;
1740  }
1741  ideal id = (ideal) h->Data();
1742  intvec* int_w = (intvec*) h->next->Data();
1743  ideal result = (ideal) MwalkInitialForm(id, int_w);
1744  res->rtyp = IDEAL_CMD;
1745  res->data = result;
1746  return FALSE;
1747  }
1748  else
1749  #endif
1750  /*==================== MivMatrixOrder =================*/
1751  #ifdef HAVE_WALK
1752  /************** Perturbation walk **********/
1753  if(strcmp(sys_cmd, "MivMatrixOrder") == 0)
1754  {
1755  if(h==NULL || h->Typ() != INTVEC_CMD)
1756  {
1757  WerrorS("system(\"MivMatrixOrder\",intvec) expected");
1758  return TRUE;
1759  }
1760  intvec* arg1 = (intvec*) h->Data();
1761  intvec* result = MivMatrixOrder(arg1);
1762  res->rtyp = INTVEC_CMD;
1763  res->data = result;
1764  return FALSE;
1765  }
1766  else
1767  #endif
1768  /*==================== MivMatrixOrderdp =================*/
1769  #ifdef HAVE_WALK
1770  if(strcmp(sys_cmd, "MivMatrixOrderdp") == 0)
1771  {
1772  if(h==NULL || h->Typ() != INT_CMD)
1773  {
1774  WerrorS("system(\"MivMatrixOrderdp\",intvec) expected");
1775  return TRUE;
1776  }
1777  int arg1 = (int) ((long)(h->Data()));
1778  intvec* result = (intvec*) MivMatrixOrderdp(arg1);
1779  res->rtyp = INTVEC_CMD;
1780  res->data = result;
1781  return FALSE;
1782  }
1783  else
1784  #endif
1785  /*==================== MPertVectors =================*/
1786  #ifdef HAVE_WALK
1787  if(strcmp(sys_cmd, "MPertVectors") == 0)
1788  {
1789  const short t[]={3,IDEAL_CMD,INTVEC_CMD,INT_CMD};
1790  if (!iiCheckTypes(h,t,1)) return TRUE;
1791  ideal arg1 = (ideal) h->Data();
1792  intvec* arg2 = (intvec*) h->next->Data();
1793  int arg3 = (int) ((long)(h->next->next->Data()));
1794  intvec* result = (intvec*) MPertVectors(arg1, arg2, arg3);
1795  res->rtyp = INTVEC_CMD;
1796  res->data = result;
1797  return FALSE;
1798  }
1799  else
1800  #endif
1801  /*==================== MPertVectorslp =================*/
1802  #ifdef HAVE_WALK
1803  if(strcmp(sys_cmd, "MPertVectorslp") == 0)
1804  {
1805  const short t[]={3,IDEAL_CMD,INTVEC_CMD,INT_CMD};
1806  if (!iiCheckTypes(h,t,1)) return TRUE;
1807  ideal arg1 = (ideal) h->Data();
1808  intvec* arg2 = (intvec*) h->next->Data();
1809  int arg3 = (int) ((long)(h->next->next->Data()));
1810  intvec* result = (intvec*) MPertVectorslp(arg1, arg2, arg3);
1811  res->rtyp = INTVEC_CMD;
1812  res->data = result;
1813  return FALSE;
1814  }
1815  else
1816  #endif
1817  /************** fractal walk **********/
1818  #ifdef HAVE_WALK
1819  if(strcmp(sys_cmd, "Mfpertvector") == 0)
1820  {
1821  const short t[]={2,IDEAL_CMD,INTVEC_CMD};
1822  if (!iiCheckTypes(h,t,1)) return TRUE;
1823  ideal arg1 = (ideal) h->Data();
1824  intvec* arg2 = (intvec*) h->next->Data();
1825  intvec* result = Mfpertvector(arg1, arg2);
1826  res->rtyp = INTVEC_CMD;
1827  res->data = result;
1828  return FALSE;
1829  }
1830  else
1831  #endif
1832  /*==================== MivUnit =================*/
1833  #ifdef HAVE_WALK
1834  if(strcmp(sys_cmd, "MivUnit") == 0)
1835  {
1836  const short t[]={1,INT_CMD};
1837  if (!iiCheckTypes(h,t,1)) return TRUE;
1838  int arg1 = (int) ((long)(h->Data()));
1839  intvec* result = (intvec*) MivUnit(arg1);
1840  res->rtyp = INTVEC_CMD;
1841  res->data = result;
1842  return FALSE;
1843  }
1844  else
1845  #endif
1846  /*==================== MivWeightOrderlp =================*/
1847  #ifdef HAVE_WALK
1848  if(strcmp(sys_cmd, "MivWeightOrderlp") == 0)
1849  {
1850  const short t[]={1,INTVEC_CMD};
1851  if (!iiCheckTypes(h,t,1)) return TRUE;
1852  intvec* arg1 = (intvec*) h->Data();
1853  intvec* result = MivWeightOrderlp(arg1);
1854  res->rtyp = INTVEC_CMD;
1855  res->data = result;
1856  return FALSE;
1857  }
1858  else
1859  #endif
1860  /*==================== MivWeightOrderdp =================*/
1861  #ifdef HAVE_WALK
1862  if(strcmp(sys_cmd, "MivWeightOrderdp") == 0)
1863  {
1864  if(h==NULL || h->Typ() != INTVEC_CMD)
1865  {
1866  WerrorS("system(\"MivWeightOrderdp\",intvec) expected");
1867  return TRUE;
1868  }
1869  intvec* arg1 = (intvec*) h->Data();
1870  //int arg2 = (int) h->next->Data();
1871  intvec* result = MivWeightOrderdp(arg1);
1872  res->rtyp = INTVEC_CMD;
1873  res->data = result;
1874  return FALSE;
1875  }
1876  else
1877  #endif
1878  /*==================== MivMatrixOrderlp =================*/
1879  #ifdef HAVE_WALK
1880  if(strcmp(sys_cmd, "MivMatrixOrderlp") == 0)
1881  {
1882  if(h==NULL || h->Typ() != INT_CMD)
1883  {
1884  WerrorS("system(\"MivMatrixOrderlp\",int) expected");
1885  return TRUE;
1886  }
1887  int arg1 = (int) ((long)(h->Data()));
1888  intvec* result = (intvec*) MivMatrixOrderlp(arg1);
1889  res->rtyp = INTVEC_CMD;
1890  res->data = result;
1891  return FALSE;
1892  }
1893  else
1894  #endif
1895  /*==================== MkInterRedNextWeight =================*/
1896  #ifdef HAVE_WALK
1897  if (strcmp(sys_cmd, "MkInterRedNextWeight") == 0)
1898  {
1899  const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
1900  if (!iiCheckTypes(h,t,1)) return TRUE;
1901  if (((intvec*) h->Data())->length() != currRing->N ||
1902  ((intvec*) h->next->Data())->length() != currRing->N)
1903  {
1904  Werror("system(\"MkInterRedNextWeight\" ...) intvecs not of length %d\n",
1905  currRing->N);
1906  return TRUE;
1907  }
1908  intvec* arg1 = (intvec*) h->Data();
1909  intvec* arg2 = (intvec*) h->next->Data();
1910  ideal arg3 = (ideal) h->next->next->Data();
1911  intvec* result = (intvec*) MkInterRedNextWeight(arg1, arg2, arg3);
1912  res->rtyp = INTVEC_CMD;
1913  res->data = result;
1914  return FALSE;
1915  }
1916  else
1917  #endif
1918  /*==================== MPertNextWeight =================*/
1919  #ifdef HAVE_WALK
1920  #ifdef MPertNextWeight
1921  if (strcmp(sys_cmd, "MPertNextWeight") == 0)
1922  {
1923  const short t[]={3,INTVEC_CMD,IDEAL_CMD,INT_CMD};
1924  if (!iiCheckTypes(h,t,1)) return TRUE;
1925  if (((intvec*) h->Data())->length() != currRing->N)
1926  {
1927  Werror("system(\"MPertNextWeight\" ...) intvecs not of length %d\n",
1928  currRing->N);
1929  return TRUE;
1930  }
1931  intvec* arg1 = (intvec*) h->Data();
1932  ideal arg2 = (ideal) h->next->Data();
1933  int arg3 = (int) h->next->next->Data();
1934  intvec* result = (intvec*) MPertNextWeight(arg1, arg2, arg3);
1935  res->rtyp = INTVEC_CMD;
1936  res->data = result;
1937  return FALSE;
1938  }
1939  else
1940  #endif //MPertNextWeight
1941  #endif
1942  /*==================== Mivperttarget =================*/
1943  #ifdef HAVE_WALK
1944  #ifdef Mivperttarget
1945  if (strcmp(sys_cmd, "Mivperttarget") == 0)
1946  {
1947  const short t[]={2,IDEAL_CMD,INT_CMD};
1948  if (!iiCheckTypes(h,t,1)) return TRUE;
1949  ideal arg1 = (ideal) h->Data();
1950  int arg2 = (int) h->next->Data();
1951  intvec* result = (intvec*) Mivperttarget(arg1, arg2);
1952  res->rtyp = INTVEC_CMD;
1953  res->data = result;
1954  return FALSE;
1955  }
1956  else
1957  #endif //Mivperttarget
1958  #endif
1959  /*==================== Mwalk =================*/
1960  #ifdef HAVE_WALK
1961  if (strcmp(sys_cmd, "Mwalk") == 0)
1962  {
1963  const short t[]={6,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,RING_CMD,INT_CMD,INT_CMD};
1964  if (!iiCheckTypes(h,t,1)) return TRUE;
1965  if (((intvec*) h->next->Data())->length() != currRing->N &&
1966  ((intvec*) h->next->next->Data())->length() != currRing->N )
1967  {
1968  Werror("system(\"Mwalk\" ...) intvecs not of length %d\n",
1969  currRing->N);
1970  return TRUE;
1971  }
1972  ideal arg1 = (ideal) h->CopyD();
1973  intvec* arg2 = (intvec*) h->next->Data();
1974  intvec* arg3 = (intvec*) h->next->next->Data();
1975  ring arg4 = (ring) h->next->next->next->Data();
1976  int arg5 = (int) (long) h->next->next->next->next->Data();
1977  int arg6 = (int) (long) h->next->next->next->next->next->Data();
1978  ideal result = (ideal) Mwalk(arg1, arg2, arg3, arg4, arg5, arg6);
1979  res->rtyp = IDEAL_CMD;
1980  res->data = result;
1981  return FALSE;
1982  }
1983  else
1984  #endif
1985  /*==================== Mpwalk =================*/
1986  #ifdef HAVE_WALK
1987  #ifdef MPWALK_ORIG
1988  if (strcmp(sys_cmd, "Mwalk") == 0)
1989  {
1990  const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,RING_CMD};
1991  if (!iiCheckTypes(h,t,1)) return TRUE;
1992  if ((((intvec*) h->next->Data())->length() != currRing->N &&
1993  ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
1994  (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
1995  ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N)))
1996  {
1997  Werror("system(\"Mwalk\" ...) intvecs not of length %d or %d\n",
1998  currRing->N,(currRing->N)*(currRing->N));
1999  return TRUE;
2000  }
2001  ideal arg1 = (ideal) h->Data();
2002  intvec* arg2 = (intvec*) h->next->Data();
2003  intvec* arg3 = (intvec*) h->next->next->Data();
2004  ring arg4 = (ring) h->next->next->next->Data();
2005  ideal result = (ideal) Mwalk(arg1, arg2, arg3,arg4);
2006  res->rtyp = IDEAL_CMD;
2007  res->data = result;
2008  return FALSE;
2009  }
2010  else
2011  #else
2012  if (strcmp(sys_cmd, "Mpwalk") == 0)
2013  {
2015  if (!iiCheckTypes(h,t,1)) return TRUE;
2016  if(((intvec*) h->next->next->next->Data())->length() != currRing->N &&
2017  ((intvec*) h->next->next->next->next->Data())->length()!=currRing->N)
2018  {
2019  Werror("system(\"Mpwalk\" ...) intvecs not of length %d\n",currRing->N);
2020  return TRUE;
2021  }
2022  ideal arg1 = (ideal) h->Data();
2023  int arg2 = (int) (long) h->next->Data();
2024  int arg3 = (int) (long) h->next->next->Data();
2025  intvec* arg4 = (intvec*) h->next->next->next->Data();
2026  intvec* arg5 = (intvec*) h->next->next->next->next->Data();
2027  int arg6 = (int) (long) h->next->next->next->next->next->Data();
2028  int arg7 = (int) (long) h->next->next->next->next->next->next->Data();
2029  int arg8 = (int) (long) h->next->next->next->next->next->next->next->Data();
2030  ideal result = (ideal) Mpwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2031  res->rtyp = IDEAL_CMD;
2032  res->data = result;
2033  return FALSE;
2034  }
2035  else
2036  #endif
2037  #endif
2038  /*==================== Mrwalk =================*/
2039  #ifdef HAVE_WALK
2040  if (strcmp(sys_cmd, "Mrwalk") == 0)
2041  {
2043  if (!iiCheckTypes(h,t,1)) return TRUE;
2044  if(((intvec*) h->next->Data())->length() != currRing->N &&
2045  ((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
2046  ((intvec*) h->next->next->Data())->length() != currRing->N &&
2047  ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) )
2048  {
2049  Werror("system(\"Mrwalk\" ...) intvecs not of length %d or %d\n",
2050  currRing->N,(currRing->N)*(currRing->N));
2051  return TRUE;
2052  }
2053  ideal arg1 = (ideal) h->Data();
2054  intvec* arg2 = (intvec*) h->next->Data();
2055  intvec* arg3 = (intvec*) h->next->next->Data();
2056  int arg4 = (int)(long) h->next->next->next->Data();
2057  int arg5 = (int)(long) h->next->next->next->next->Data();
2058  int arg6 = (int)(long) h->next->next->next->next->next->Data();
2059  int arg7 = (int)(long) h->next->next->next->next->next->next->Data();
2060  ideal result = (ideal) Mrwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2061  res->rtyp = IDEAL_CMD;
2062  res->data = result;
2063  return FALSE;
2064  }
2065  else
2066  #endif
2067  /*==================== MAltwalk1 =================*/
2068  #ifdef HAVE_WALK
2069  if (strcmp(sys_cmd, "MAltwalk1") == 0)
2070  {
2071  const short t[]={5,IDEAL_CMD,INT_CMD,INT_CMD,INTVEC_CMD,INTVEC_CMD};
2072  if (!iiCheckTypes(h,t,1)) return TRUE;
2073  if (((intvec*) h->next->next->next->Data())->length() != currRing->N &&
2074  ((intvec*) h->next->next->next->next->Data())->length()!=currRing->N)
2075  {
2076  Werror("system(\"MAltwalk1\" ...) intvecs not of length %d\n",
2077  currRing->N);
2078  return TRUE;
2079  }
2080  ideal arg1 = (ideal) h->Data();
2081  int arg2 = (int) ((long)(h->next->Data()));
2082  int arg3 = (int) ((long)(h->next->next->Data()));
2083  intvec* arg4 = (intvec*) h->next->next->next->Data();
2084  intvec* arg5 = (intvec*) h->next->next->next->next->Data();
2085  ideal result = (ideal) MAltwalk1(arg1, arg2, arg3, arg4, arg5);
2086  res->rtyp = IDEAL_CMD;
2087  res->data = result;
2088  return FALSE;
2089  }
2090  else
2091  #endif
2092  /*==================== MAltwalk1 =================*/
2093  #ifdef HAVE_WALK
2094  #ifdef MFWALK_ALT
2095  if (strcmp(sys_cmd, "Mfwalk_alt") == 0)
2096  {
2097  const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD};
2098  if (!iiCheckTypes(h,t,1)) return TRUE;
2099  if (((intvec*) h->next->Data())->length() != currRing->N &&
2100  ((intvec*) h->next->next->Data())->length() != currRing->N )
2101  {
2102  Werror("system(\"Mfwalk\" ...) intvecs not of length %d\n",
2103  currRing->N);
2104  return TRUE;
2105  }
2106  ideal arg1 = (ideal) h->Data();
2107  intvec* arg2 = (intvec*) h->next->Data();
2108  intvec* arg3 = (intvec*) h->next->next->Data();
2109  int arg4 = (int) h->next->next->next->Data();
2110  ideal result = (ideal) Mfwalk_alt(arg1, arg2, arg3, arg4);
2111  res->rtyp = IDEAL_CMD;
2112  res->data = result;
2113  return FALSE;
2114  }
2115  else
2116  #endif
2117  #endif
2118  /*==================== Mfwalk =================*/
2119  #ifdef HAVE_WALK
2120  if (strcmp(sys_cmd, "Mfwalk") == 0)
2121  {
2122  const short t[]={5,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD};
2123  if (!iiCheckTypes(h,t,1)) return TRUE;
2124  if (((intvec*) h->next->Data())->length() != currRing->N &&
2125  ((intvec*) h->next->next->Data())->length() != currRing->N )
2126  {
2127  Werror("system(\"Mfwalk\" ...) intvecs not of length %d\n",
2128  currRing->N);
2129  return TRUE;
2130  }
2131  ideal arg1 = (ideal) h->Data();
2132  intvec* arg2 = (intvec*) h->next->Data();
2133  intvec* arg3 = (intvec*) h->next->next->Data();
2134  int arg4 = (int)(long) h->next->next->next->Data();
2135  int arg5 = (int)(long) h->next->next->next->next->Data();
2136  ideal result = (ideal) Mfwalk(arg1, arg2, arg3, arg4, arg5);
2137  res->rtyp = IDEAL_CMD;
2138  res->data = result;
2139  return FALSE;
2140  }
2141  else
2142  #endif
2143  /*==================== Mfrwalk =================*/
2144  #ifdef HAVE_WALK
2145  if (strcmp(sys_cmd, "Mfrwalk") == 0)
2146  {
2147  const short t[]={6,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD};
2148  if (!iiCheckTypes(h,t,1)) return TRUE;
2149 /*
2150  if (((intvec*) h->next->Data())->length() != currRing->N &&
2151  ((intvec*) h->next->next->Data())->length() != currRing->N)
2152  {
2153  Werror("system(\"Mfrwalk\" ...) intvecs not of length %d\n",currRing->N);
2154  return TRUE;
2155  }
2156 */
2157  if((((intvec*) h->next->Data())->length() != currRing->N &&
2158  ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
2159  (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
2160  ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
2161  {
2162  Werror("system(\"Mfrwalk\" ...) intvecs not of length %d or %d\n",
2163  currRing->N,(currRing->N)*(currRing->N));
2164  return TRUE;
2165  }
2166 
2167  ideal arg1 = (ideal) h->Data();
2168  intvec* arg2 = (intvec*) h->next->Data();
2169  intvec* arg3 = (intvec*) h->next->next->Data();
2170  int arg4 = (int)(long) h->next->next->next->Data();
2171  int arg5 = (int)(long) h->next->next->next->next->Data();
2172  int arg6 = (int)(long) h->next->next->next->next->next->Data();
2173  ideal result = (ideal) Mfrwalk(arg1, arg2, arg3, arg4, arg5, arg6);
2174  res->rtyp = IDEAL_CMD;
2175  res->data = result;
2176  return FALSE;
2177  }
2178  else
2179  /*==================== Mprwalk =================*/
2180  if (strcmp(sys_cmd, "Mprwalk") == 0)
2181  {
2183  if (!iiCheckTypes(h,t,1)) return TRUE;
2184  if((((intvec*) h->next->Data())->length() != currRing->N &&
2185  ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
2186  (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
2187  ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
2188  {
2189  Werror("system(\"Mrwalk\" ...) intvecs not of length %d or %d\n",
2190  currRing->N,(currRing->N)*(currRing->N));
2191  return TRUE;
2192  }
2193  ideal arg1 = (ideal) h->Data();
2194  intvec* arg2 = (intvec*) h->next->Data();
2195  intvec* arg3 = (intvec*) h->next->next->Data();
2196  int arg4 = (int)(long) h->next->next->next->Data();
2197  int arg5 = (int)(long) h->next->next->next->next->Data();
2198  int arg6 = (int)(long) h->next->next->next->next->next->Data();
2199  int arg7 = (int)(long) h->next->next->next->next->next->next->Data();
2200  int arg8 = (int)(long) h->next->next->next->next->next->next->next->Data();
2201  int arg9 = (int)(long) h->next->next->next->next->next->next->next->next->Data();
2202  ideal result = (ideal) Mprwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
2203  res->rtyp = IDEAL_CMD;
2204  res->data = result;
2205  return FALSE;
2206  }
2207  else
2208  #endif
2209  /*==================== TranMImprovwalk =================*/
2210  #ifdef HAVE_WALK
2211  #ifdef TRAN_Orig
2212  if (strcmp(sys_cmd, "TranMImprovwalk") == 0)
2213  {
2214  const short t[]={3,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD};
2215  if (!iiCheckTypes(h,t,1)) return TRUE;
2216  if (((intvec*) h->next->Data())->length() != currRing->N &&
2217  ((intvec*) h->next->next->Data())->length() != currRing->N )
2218  {
2219  Werror("system(\"TranMImprovwalk\" ...) intvecs not of length %d\n",
2220  currRing->N);
2221  return TRUE;
2222  }
2223  ideal arg1 = (ideal) h->Data();
2224  intvec* arg2 = (intvec*) h->next->Data();
2225  intvec* arg3 = (intvec*) h->next->next->Data();
2226  ideal result = (ideal) TranMImprovwalk(arg1, arg2, arg3);
2227  res->rtyp = IDEAL_CMD;
2228  res->data = result;
2229  return FALSE;
2230  }
2231  else
2232  #endif
2233  #endif
2234  /*==================== MAltwalk2 =================*/
2235  #ifdef HAVE_WALK
2236  if (strcmp(sys_cmd, "MAltwalk2") == 0)
2237  {
2238  const short t[]={3,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD};
2239  if (!iiCheckTypes(h,t,1)) return TRUE;
2240  if (((intvec*) h->next->Data())->length() != currRing->N &&
2241  ((intvec*) h->next->next->Data())->length() != currRing->N )
2242  {
2243  Werror("system(\"MAltwalk2\" ...) intvecs not of length %d\n",
2244  currRing->N);
2245  return TRUE;
2246  }
2247  ideal arg1 = (ideal) h->Data();
2248  intvec* arg2 = (intvec*) h->next->Data();
2249  intvec* arg3 = (intvec*) h->next->next->Data();
2250  ideal result = (ideal) MAltwalk2(arg1, arg2, arg3);
2251  res->rtyp = IDEAL_CMD;
2252  res->data = result;
2253  return FALSE;
2254  }
2255  else
2256  #endif
2257  /*==================== MAltwalk2 =================*/
2258  #ifdef HAVE_WALK
2259  if (strcmp(sys_cmd, "TranMImprovwalk") == 0)
2260  {
2261  const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD};
2262  if (!iiCheckTypes(h,t,1)) return TRUE;
2263  if (((intvec*) h->next->Data())->length() != currRing->N &&
2264  ((intvec*) h->next->next->Data())->length() != currRing->N )
2265  {
2266  Werror("system(\"TranMImprovwalk\" ...) intvecs not of length %d\n",
2267  currRing->N);
2268  return TRUE;
2269  }
2270  ideal arg1 = (ideal) h->Data();
2271  intvec* arg2 = (intvec*) h->next->Data();
2272  intvec* arg3 = (intvec*) h->next->next->Data();
2273  int arg4 = (int) ((long)(h->next->next->next->Data()));
2274  ideal result = (ideal) TranMImprovwalk(arg1, arg2, arg3, arg4);
2275  res->rtyp = IDEAL_CMD;
2276  res->data = result;
2277  return FALSE;
2278  }
2279  else
2280  #endif
2281  /*==================== TranMrImprovwalk =================*/
2282  #if 0
2283  #ifdef HAVE_WALK
2284  if (strcmp(sys_cmd, "TranMrImprovwalk") == 0)
2285  {
2286  if (h == NULL || h->Typ() != IDEAL_CMD ||
2287  h->next == NULL || h->next->Typ() != INTVEC_CMD ||
2288  h->next->next == NULL || h->next->next->Typ() != INTVEC_CMD ||
2289  h->next->next->next == NULL || h->next->next->next->Typ() != INT_CMD ||
2290  h->next->next->next == NULL || h->next->next->next->next->Typ() != INT_CMD ||
2291  h->next->next->next == NULL || h->next->next->next->next->next->Typ() != INT_CMD)
2292  {
2293  WerrorS("system(\"TranMrImprovwalk\", ideal, intvec, intvec) expected");
2294  return TRUE;
2295  }
2296  if (((intvec*) h->next->Data())->length() != currRing->N &&
2297  ((intvec*) h->next->next->Data())->length() != currRing->N )
2298  {
2299  Werror("system(\"TranMrImprovwalk\" ...) intvecs not of length %d\n", currRing->N);
2300  return TRUE;
2301  }
2302  ideal arg1 = (ideal) h->Data();
2303  intvec* arg2 = (intvec*) h->next->Data();
2304  intvec* arg3 = (intvec*) h->next->next->Data();
2305  int arg4 = (int)(long) h->next->next->next->Data();
2306  int arg5 = (int)(long) h->next->next->next->next->Data();
2307  int arg6 = (int)(long) h->next->next->next->next->next->Data();
2308  ideal result = (ideal) TranMrImprovwalk(arg1, arg2, arg3, arg4, arg5, arg6);
2309  res->rtyp = IDEAL_CMD;
2310  res->data = result;
2311  return FALSE;
2312  }
2313  else
2314  #endif
2315  #endif
2316  /*================= Extended system call ========================*/
2317  {
2318  #ifndef MAKE_DISTRIBUTION
2319  return(jjEXTENDED_SYSTEM(res, args));
2320  #else
2321  Werror( "system(\"%s\",...) %s", sys_cmd, feNotImplemented );
2322  #endif
2323  }
2324  } /* typ==string */
2325  return TRUE;
2326 }
2327 
2328 
2329 #ifdef HAVE_EXTENDED_SYSTEM
2330  // You can put your own system calls here
2331 # include "kernel/fglm/fglm.h"
2332 # ifdef HAVE_NEWTON
2333 # include "hc_newton.h"
2334 # endif
2335 # include "polys/mod_raw.h"
2336 # include "polys/monomials/ring.h"
2337 # include "kernel/GBEngine/shiftgb.h"
2338 # include "kernel/GBEngine/kutil.h"
2339 
2341 {
2342  if(h->Typ() == STRING_CMD)
2343  {
2344  char *sys_cmd=(char *)(h->Data());
2345  h=h->next;
2346  /*==================== test syz strat =================*/
2347  if (strcmp(sys_cmd, "syz") == 0)
2348  {
2349  if ((h!=NULL) && (h->Typ()==STRING_CMD))
2350  {
2351  const char *s=(const char *)h->Data();
2352  if (strcmp(s,"posInT_EcartFDegpLength")==0)
2354  else if (strcmp(s,"posInT_FDegpLength")==0)
2356  else if (strcmp(s,"posInT_pLength")==0)
2358  else if (strcmp(s,"posInT0")==0)
2360  else if (strcmp(s,"posInT1")==0)
2362  else if (strcmp(s,"posInT2")==0)
2364  else if (strcmp(s,"posInT11")==0)
2366  else if (strcmp(s,"posInT110")==0)
2368  else if (strcmp(s,"posInT13")==0)
2370  else if (strcmp(s,"posInT15")==0)
2372  else if (strcmp(s,"posInT17")==0)
2374  else if (strcmp(s,"posInT17_c")==0)
2376  else if (strcmp(s,"posInT19")==0)
2378  else PrintS("valid posInT:0,1,2,11,110,13,15,17,17_c,19,_EcartFDegpLength,_FDegpLength,_pLength,_EcartpLength\n");
2379  }
2380  else
2381  {
2382  test_PosInT=NULL;
2383  test_PosInL=NULL;
2384  }
2385  si_opt_2|=Sy_bit(23);
2386  return FALSE;
2387  }
2388  else
2389  /*==================== locNF ======================================*/
2390  if(strcmp(sys_cmd,"locNF")==0)
2391  {
2392  const short t[]={4,VECTOR_CMD,MODUL_CMD,INT_CMD,INTVEC_CMD};
2393  if (iiCheckTypes(h,t,1))
2394  {
2395  poly f=(poly)h->Data();
2396  h=h->next;
2397  ideal m=(ideal)h->Data();
2398  assumeStdFlag(h);
2399  h=h->next;
2400  int n=(int)((long)h->Data());
2401  h=h->next;
2402  intvec *v=(intvec *)h->Data();
2403 
2404  /* == now the work starts == */
2405 
2406  short * iv=iv2array(v, currRing);
2407  poly r=0;
2408  poly hp=ppJetW(f,n,iv);
2409  int s=MATCOLS(m);
2410  int j=0;
2411  matrix T=mp_InitI(s,1,0, currRing);
2412 
2413  while (hp != NULL)
2414  {
2415  if (pDivisibleBy(m->m[j],hp))
2416  {
2417  if (MATELEM(T,j+1,1)==0)
2418  {
2419  MATELEM(T,j+1,1)=pDivideM(pHead(hp),pHead(m->m[j]));
2420  }
2421  else
2422  {
2423  pAdd(MATELEM(T,j+1,1),pDivideM(pHead(hp),pHead(m->m[j])));
2424  }
2425  hp=ppJetW(ksOldSpolyRed(m->m[j],hp,0),n,iv);
2426  j=0;
2427  }
2428  else
2429  {
2430  if (j==s-1)
2431  {
2432  r=pAdd(r,pHead(hp));
2433  hp=pLmDeleteAndNext(hp); /* hp=pSub(hp,pHead(hp));*/
2434  j=0;
2435  }
2436  else
2437  {
2438  j++;
2439  }
2440  }
2441  }
2442 
2445  for (int k=1;k<=MATROWS(Temp);k++)
2446  {
2447  MATELEM(R,k,1)=MATELEM(Temp,k,1);
2448  }
2449 
2451  L->Init(2);
2452  L->m[0].rtyp=MATRIX_CMD; L->m[0].data=(void *)R;
2453  L->m[1].rtyp=MATRIX_CMD; L->m[1].data=(void *)T;
2454  res->data=L;
2455  res->rtyp=LIST_CMD;
2456  // iv aufraeumen
2457  omFree(iv);
2458  return FALSE;
2459  }
2460  else
2461  return TRUE;
2462  }
2463  else
2464  /*==================== poly debug ==================================*/
2465  if(strcmp(sys_cmd,"p")==0)
2466  {
2467 # ifdef RDEBUG
2468  p_DebugPrint((poly)h->Data(), currRing);
2469 # else
2470  WarnS("Sorry: not available for release build!");
2471 # endif
2472  return FALSE;
2473  }
2474  else
2475  /*==================== setsyzcomp ==================================*/
2476  if(strcmp(sys_cmd,"setsyzcomp")==0)
2477  {
2478  if ((h!=NULL) && (h->Typ()==INT_CMD))
2479  {
2480  int k = (int)(long)h->Data();
2481  if ( currRing->order[0] == ringorder_s )
2482  {
2484  }
2485  }
2486  }
2487  /*==================== ring debug ==================================*/
2488  if(strcmp(sys_cmd,"r")==0)
2489  {
2490 # ifdef RDEBUG
2491  rDebugPrint((ring)h->Data());
2492 # else
2493  WarnS("Sorry: not available for release build!");
2494 # endif
2495  return FALSE;
2496  }
2497  else
2498  /*==================== changeRing ========================*/
2499  /* The following code changes the names of the variables in the
2500  current ring to "x1", "x2", ..., "xN", where N is the number
2501  of variables in the current ring.
2502  The purpose of this rewriting is to eliminate indexed variables,
2503  as they may cause problems when generating scripts for Magma,
2504  Maple, or Macaulay2. */
2505  if(strcmp(sys_cmd,"changeRing")==0)
2506  {
2507  int varN = currRing->N;
2508  char h[10];
2509  for (int i = 1; i <= varN; i++)
2510  {
2511  omFree(currRing->names[i - 1]);
2512  sprintf(h, "x%d", i);
2513  currRing->names[i - 1] = omStrDup(h);
2514  }
2516  res->rtyp = INT_CMD;
2517  res->data = (void*)0L;
2518  return FALSE;
2519  }
2520  else
2521  /*==================== mtrack ==================================*/
2522  if(strcmp(sys_cmd,"mtrack")==0)
2523  {
2524  #ifdef OM_TRACK
2525  om_Opts.MarkAsStatic = 1;
2526  FILE *fd = NULL;
2527  int max = 5;
2528  while (h != NULL)
2529  {
2531  if (fd == NULL && h->Typ()==STRING_CMD)
2532  {
2533  char *fn=(char*) h->Data();
2534  fd = fopen(fn, "w");
2535  if (fd == NULL)
2536  Warn("Can not open %s for writing og mtrack. Using stdout",fn);
2537  }
2538  else if (h->Typ() == INT_CMD)
2539  {
2540  max = (int)(long)h->Data();
2541  }
2542  h = h->Next();
2543  }
2544  omPrintUsedTrackAddrs((fd == NULL ? stdout : fd), max);
2545  if (fd != NULL) fclose(fd);
2546  om_Opts.MarkAsStatic = 0;
2547  return FALSE;
2548  #else
2549  WerrorS("system(\"mtrack\",..) is not implemented in this version");
2550  return TRUE;
2551  #endif
2552  }
2553  else
2554  /*==================== backtrace ==================================*/
2555  #ifndef OM_NDEBUG
2556  if(strcmp(sys_cmd,"backtrace")==0)
2557  {
2558  omPrintCurrentBackTrace(stdout);
2559  return FALSE;
2560  }
2561  else
2562  #endif
2563 
2564 #if !defined(OM_NDEBUG)
2565  /*==================== omMemoryTest ==================================*/
2566  if (strcmp(sys_cmd,"omMemoryTest")==0)
2567  {
2568 
2569 #ifdef OM_STATS_H
2570  PrintS("\n[om_Info]: \n");
2571  omUpdateInfo();
2572 #define OM_PRINT(name) Print(" %-22s : %10ld \n", #name, om_Info . name)
2573  OM_PRINT(MaxBytesSystem);
2574  OM_PRINT(CurrentBytesSystem);
2575  OM_PRINT(MaxBytesSbrk);
2576  OM_PRINT(CurrentBytesSbrk);
2577  OM_PRINT(MaxBytesMmap);
2578  OM_PRINT(CurrentBytesMmap);
2579  OM_PRINT(UsedBytes);
2580  OM_PRINT(AvailBytes);
2581  OM_PRINT(UsedBytesMalloc);
2582  OM_PRINT(AvailBytesMalloc);
2583  OM_PRINT(MaxBytesFromMalloc);
2584  OM_PRINT(CurrentBytesFromMalloc);
2585  OM_PRINT(MaxBytesFromValloc);
2586  OM_PRINT(CurrentBytesFromValloc);
2587  OM_PRINT(UsedBytesFromValloc);
2588  OM_PRINT(AvailBytesFromValloc);
2589  OM_PRINT(MaxPages);
2590  OM_PRINT(UsedPages);
2591  OM_PRINT(AvailPages);
2592  OM_PRINT(MaxRegionsAlloc);
2593  OM_PRINT(CurrentRegionsAlloc);
2594 #undef OM_PRINT
2595 #endif
2596 
2597 #ifdef OM_OPTS_H
2598  PrintS("\n[om_Opts]: \n");
2599 #define OM_PRINT(format, name) Print(" %-22s : %10" format"\n", #name, om_Opts . name)
2600  OM_PRINT("d", MinTrack);
2601  OM_PRINT("d", MinCheck);
2602  OM_PRINT("d", MaxTrack);
2603  OM_PRINT("d", MaxCheck);
2604  OM_PRINT("d", Keep);
2605  OM_PRINT("d", HowToReportErrors);
2606  OM_PRINT("d", MarkAsStatic);
2607  OM_PRINT("u", PagesPerRegion);
2608  OM_PRINT("p", OutOfMemoryFunc);
2609  OM_PRINT("p", MemoryLowFunc);
2610  OM_PRINT("p", ErrorHook);
2611 #undef OM_PRINT
2612 #endif
2613 
2614 #ifdef OM_ERROR_H
2615  Print("\n\n[om_ErrorStatus] : '%s' (%s)\n",
2618  Print("[om_InternalErrorStatus]: '%s' (%s)\n",
2621 
2622 #endif
2623 
2624 // omTestMemory(1);
2625 // omtTestErrors();
2626  return FALSE;
2627  }
2628  else
2629 #endif
2630  /*==================== pDivStat =============================*/
2631  #if defined(PDEBUG) || defined(PDIV_DEBUG)
2632  if(strcmp(sys_cmd,"pDivStat")==0)
2633  {
2634  extern void pPrintDivisbleByStat();
2636  return FALSE;
2637  }
2638  else
2639  #endif
2640  /*==================== red =============================*/
2641  #if 0
2642  if(strcmp(sys_cmd,"red")==0)
2643  {
2644  if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
2645  {
2646  res->rtyp=IDEAL_CMD;
2647  res->data=(void *)kStdred((ideal)h->Data(),NULL,testHomog,NULL);
2648  setFlag(res,FLAG_STD);
2649  return FALSE;
2650  }
2651  else
2652  WerrorS("ideal expected");
2653  }
2654  else
2655  #endif
2656  /*==================== fastcomb =============================*/
2657  if(strcmp(sys_cmd,"fastcomb")==0)
2658  {
2659  if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
2660  {
2661  if (h->next!=NULL)
2662  {
2663  if (h->next->Typ()!=POLY_CMD)
2664  {
2665  WarnS("Wrong types for poly= comb(ideal,poly)");
2666  }
2667  }
2668  res->rtyp=POLY_CMD;
2669  res->data=(void *) fglmLinearCombination(
2670  (ideal)h->Data(),(poly)h->next->Data());
2671  return FALSE;
2672  }
2673  else
2674  WerrorS("ideal expected");
2675  }
2676  else
2677  /*==================== comb =============================*/
2678  if(strcmp(sys_cmd,"comb")==0)
2679  {
2680  if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
2681  {
2682  if (h->next!=NULL)
2683  {
2684  if (h->next->Typ()!=POLY_CMD)
2685  {
2686  WarnS("Wrong types for poly= comb(ideal,poly)");
2687  }
2688  }
2689  res->rtyp=POLY_CMD;
2690  res->data=(void *)fglmNewLinearCombination(
2691  (ideal)h->Data(),(poly)h->next->Data());
2692  return FALSE;
2693  }
2694  else
2695  WerrorS("ideal expected");
2696  }
2697  else
2698  #if 0 /* debug only */
2699  /*==================== listall ===================================*/
2700  if(strcmp(sys_cmd,"listall")==0)
2701  {
2702  void listall(int showproc);
2703  int showproc=0;
2704  if ((h!=NULL) && (h->Typ()==INT_CMD)) showproc=(int)((long)h->Data());
2705  listall(showproc);
2706  return FALSE;
2707  }
2708  else
2709  #endif
2710  #if 0 /* debug only */
2711  /*==================== proclist =================================*/
2712  if(strcmp(sys_cmd,"proclist")==0)
2713  {
2714  void piShowProcList();
2715  piShowProcList();
2716  return FALSE;
2717  }
2718  else
2719  #endif
2720  /* ==================== newton ================================*/
2721  #ifdef HAVE_NEWTON
2722  if(strcmp(sys_cmd,"newton")==0)
2723  {
2724  if ((h->Typ()!=POLY_CMD)
2725  || (h->next->Typ()!=INT_CMD)
2726  || (h->next->next->Typ()!=INT_CMD))
2727  {
2728  WerrorS("system(\"newton\",<poly>,<int>,<int>) expected");
2729  return TRUE;
2730  }
2731  poly p=(poly)(h->Data());
2732  int l=pLength(p);
2733  short *points=(short *)omAlloc(currRing->N*l*sizeof(short));
2734  int i,j,k;
2735  k=0;
2736  poly pp=p;
2737  for (i=0;pp!=NULL;i++)
2738  {
2739  for(j=1;j<=currRing->N;j++)
2740  {
2741  points[k]=pGetExp(pp,j);
2742  k++;
2743  }
2744  pIter(pp);
2745  }
2746  hc_ERG r=hc_KOENIG(currRing->N, // dimension
2747  l, // number of points
2748  (short*) points, // points: x_1, y_1,z_1, x_2,y_2,z2,...
2749  currRing->OrdSgn==-1,
2750  (int) (h->next->Data()), // 1: Milnor, 0: Newton
2751  (int) (h->next->next->Data()) // debug
2752  );
2753  //----<>---Output-----------------------
2754 
2755 
2756  // PrintS("Bin jetzt in extra.cc bei der Auswertung.\n"); // **********
2757 
2758 
2760  L->Init(6);
2761  L->m[0].rtyp=STRING_CMD; // newtonnumber;
2762  L->m[0].data=(void *)omStrDup(r.nZahl);
2763  L->m[1].rtyp=INT_CMD;
2764  L->m[1].data=(void *)(long)r.achse; // flag for unoccupied axes
2765  L->m[2].rtyp=INT_CMD;
2766  L->m[2].data=(void *)(long)r.deg; // #degenerations
2767  if ( r.deg != 0) // only if degenerations exist
2768  {
2769  L->m[3].rtyp=INT_CMD;
2770  L->m[3].data=(void *)(long)r.anz_punkte; // #points
2771  //---<>--number of points------
2772  int anz = r.anz_punkte; // number of points
2773  int dim = (currRing->N); // dimension
2774  intvec* v = new intvec( anz*dim );
2775  for (i=0; i<anz*dim; i++) // copy points
2776  (*v)[i] = r.pu[i];
2777  L->m[4].rtyp=INTVEC_CMD;
2778  L->m[4].data=(void *)v;
2779  //---<>--degenerations---------
2780  int deg = r.deg; // number of points
2781  intvec* w = new intvec( r.speicher ); // necessary memory
2782  i=0; // start copying
2783  do
2784  {
2785  (*w)[i] = r.deg_tab[i];
2786  i++;
2787  }
2788  while (r.deg_tab[i-1] != -2); // mark for end of list
2789  L->m[5].rtyp=INTVEC_CMD;
2790  L->m[5].data=(void *)w;
2791  }
2792  else
2793  {
2794  L->m[3].rtyp=INT_CMD; L->m[3].data=(char *)0;
2795  L->m[4].rtyp=DEF_CMD;
2796  L->m[5].rtyp=DEF_CMD;
2797  }
2798 
2799  res->data=(void *)L;
2800  res->rtyp=LIST_CMD;
2801  // free all pointer in r:
2802  delete[] r.nZahl;
2803  delete[] r.pu;
2804  delete[] r.deg_tab; // Ist das ein Problem??
2805 
2806  omFreeSize((ADDRESS)points,currRing->N*l*sizeof(short));
2807  return FALSE;
2808  }
2809  else
2810  #endif
2811  /*==== connection to Sebastian Jambor's code ======*/
2812  /* This code connects Sebastian Jambor's code for
2813  computing the minimal polynomial of an (n x n) matrix
2814  with entries in F_p to SINGULAR. Two conversion methods
2815  are needed; see further up in this file:
2816  (1) conversion of a matrix with long entries to
2817  a SINGULAR matrix with number entries, where
2818  the numbers are coefficients in currRing;
2819  (2) conversion of an array of longs (encoding the
2820  coefficients of the minimal polynomial) to a
2821  SINGULAR poly living in currRing. */
2822  if (strcmp(sys_cmd, "minpoly") == 0)
2823  {
2824  if ((h == NULL) || (h->Typ() != MATRIX_CMD) || h->next != NULL)
2825  {
2826  Werror("expected exactly one argument: %s",
2827  "a square matrix with number entries");
2828  return TRUE;
2829  }
2830  else
2831  {
2832  matrix m = (matrix)h->Data();
2833  int n = m->rows();
2834  unsigned long p = (unsigned long)n_GetChar(currRing->cf);
2835  if (n != m->cols())
2836  {
2837  WerrorS("expected exactly one argument: "
2838  "a square matrix with number entries");
2839  return TRUE;
2840  }
2841  unsigned long** ml = singularMatrixToLongMatrix(m);
2842  unsigned long* polyCoeffs = computeMinimalPolynomial(ml, n, p);
2843  poly theMinPoly = longCoeffsToSingularPoly(polyCoeffs, n);
2844  res->rtyp = POLY_CMD;
2845  res->data = (void *)theMinPoly;
2846  for (int i = 0; i < n; i++) delete[] ml[i];
2847  delete[] ml;
2848  delete[] polyCoeffs;
2849  return FALSE;
2850  }
2851  }
2852  else
2853  /*==================== sdb_flags =================*/
2854  #ifdef HAVE_SDB
2855  if (strcmp(sys_cmd, "sdb_flags") == 0)
2856  {
2857  if ((h!=NULL) && (h->Typ()==INT_CMD))
2858  {
2859  sdb_flags=(int)((long)h->Data());
2860  }
2861  else
2862  {
2863  WerrorS("system(\"sdb_flags\",`int`) expected");
2864  return TRUE;
2865  }
2866  return FALSE;
2867  }
2868  else
2869  #endif
2870  /*==================== sdb_edit =================*/
2871  #ifdef HAVE_SDB
2872  if (strcmp(sys_cmd, "sdb_edit") == 0)
2873  {
2874  if ((h!=NULL) && (h->Typ()==PROC_CMD))
2875  {
2876  procinfov p=(procinfov)h->Data();
2877  sdb_edit(p);
2878  }
2879  else
2880  {
2881  WerrorS("system(\"sdb_edit\",`proc`) expected");
2882  return TRUE;
2883  }
2884  return FALSE;
2885  }
2886  else
2887  #endif
2888  /*==================== GF =================*/
2889  #if 0 // for testing only
2890  if (strcmp(sys_cmd, "GF") == 0)
2891  {
2892  if ((h!=NULL) && (h->Typ()==POLY_CMD))
2893  {
2894  int c=rChar(currRing);
2895  setCharacteristic( c,nfMinPoly[0], currRing->parameter[0][0] );
2896  CanonicalForm F( convSingGFFactoryGF( (poly)h->Data(), currRing ) );
2897  res->rtyp=POLY_CMD;
2898  res->data=convFactoryGFSingGF( F, currRing );
2899  return FALSE;
2900  }
2901  else { WerrorS("wrong typ"); return TRUE;}
2902  }
2903  else
2904  #endif
2905  /*==================== SVD =================*/
2906  #ifdef HAVE_SVD
2907  if (strcmp(sys_cmd, "svd") == 0)
2908  {
2909  extern lists testsvd(matrix M);
2910  res->rtyp=LIST_CMD;
2911  res->data=(char*)(testsvd((matrix)h->Data()));
2912  return FALSE;
2913  }
2914  else
2915  #endif
2916 
2917 
2918  /*==================== DLL =================*/
2919  #ifdef __CYGWIN__
2920  #ifdef HAVE_DL
2921  /* testing the DLL functionality under Win32 */
2922  if (strcmp(sys_cmd, "DLL") == 0)
2923  {
2924  typedef void (*Void_Func)();
2925  typedef int (*Int_Func)(int);
2926  void *hh=dynl_open("WinDllTest.dll");
2927  if ((h!=NULL) && (h->Typ()==INT_CMD))
2928  {
2929  int (*f)(int);
2930  if (hh!=NULL)
2931  {
2932  int (*f)(int);
2933  f=(Int_Func)dynl_sym(hh,"PlusDll");
2934  int i=10;
2935  if (f!=NULL) printf("%d\n",f(i));
2936  else PrintS("cannot find PlusDll\n");
2937  }
2938  }
2939  else
2940  {
2941  void (*f)();
2942  f= (Void_Func)dynl_sym(hh,"TestDll");
2943  if (f!=NULL) f();
2944  else PrintS("cannot find TestDll\n");
2945  }
2946  return FALSE;
2947  }
2948  else
2949  #endif
2950  #endif
2951  #ifdef HAVE_RING2TOM
2952  /*==================== ring-GB ==================================*/
2953  if (strcmp(sys_cmd, "findZeroPoly")==0)
2954  {
2955  ring r = currRing;
2956  poly f = (poly) h->Data();
2957  res->rtyp=POLY_CMD;
2958  res->data=(poly) kFindZeroPoly(f, r, r);
2959  return(FALSE);
2960  }
2961  else
2962  /*==================== Creating zero polynomials =================*/
2963  #ifdef HAVE_VANIDEAL
2964  if (strcmp(sys_cmd, "createG0")==0)
2965  {
2966  /* long exp[50];
2967  int N = 0;
2968  while (h != NULL)
2969  {
2970  N += 1;
2971  exp[N] = (long) h->Data();
2972  // if (exp[i] % 2 != 0) exp[i] -= 1;
2973  h = h->next;
2974  }
2975  for (int k = 1; N + k <= currRing->N; k++) exp[k] = 0;
2976 
2977  poly t_p;
2978  res->rtyp=POLY_CMD;
2979  res->data= (poly) kCreateZeroPoly(exp, -1, &t_p, currRing, currRing);
2980  return(FALSE); */
2981 
2982  res->rtyp = IDEAL_CMD;
2983  res->data = (ideal) createG0();
2984  return(FALSE);
2985  }
2986  else
2987  #endif
2988  /*==================== redNF_ring =================*/
2989  if (strcmp(sys_cmd, "redNF_ring")==0)
2990  {
2991  ring r = currRing;
2992  poly f = (poly) h->Data();
2993  h = h->next;
2994  ideal G = (ideal) h->Data();
2995  res->rtyp=POLY_CMD;
2996  res->data=(poly) ringRedNF(f, G, r);
2997  return(FALSE);
2998  }
2999  else
3000  #endif
3001  /*==================== Roune Hilb =================*/
3002  if (strcmp(sys_cmd, "hilbroune") == 0)
3003  {
3004  if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
3005  {
3006  slicehilb((ideal)h->Data());
3007  }
3008  else return TRUE;
3009  return FALSE;
3010  }
3011  else
3012  /*==================== F5 Implementation =================*/
3013  #ifdef HAVE_F5
3014  if (strcmp(sys_cmd, "f5")==0)
3015  {
3016  if (h->Typ()!=IDEAL_CMD)
3017  {
3018  WerrorS("ideal expected");
3019  return TRUE;
3020  }
3021 
3022  ring r = currRing;
3023  ideal G = (ideal) h->Data();
3024  h = h->next;
3025  int opt;
3026  if(h != NULL) {
3027  opt = (int) (long) h->Data();
3028  }
3029  else {
3030  opt = 2;
3031  }
3032  h = h->next;
3033  int plus;
3034  if(h != NULL) {
3035  plus = (int) (long) h->Data();
3036  }
3037  else {
3038  plus = 0;
3039  }
3040  h = h->next;
3041  int termination;
3042  if(h != NULL) {
3043  termination = (int) (long) h->Data();
3044  }
3045  else {
3046  termination = 0;
3047  }
3048  res->rtyp=IDEAL_CMD;
3049  res->data=(ideal) F5main(G,r,opt,plus,termination);
3050  return FALSE;
3051  }
3052  else
3053  #endif
3054  /*==================== Testing groebner basis =================*/
3055  #ifdef HAVE_RINGS
3056  if (strcmp(sys_cmd, "NF_ring")==0)
3057  {
3058  ring r = currRing;
3059  poly f = (poly) h->Data();
3060  h = h->next;
3061  ideal G = (ideal) h->Data();
3062  res->rtyp=POLY_CMD;
3063  res->data=(poly) ringNF(f, G, r);
3064  return(FALSE);
3065  }
3066  else
3067  if (strcmp(sys_cmd, "spoly")==0)
3068  {
3069  poly f = pCopy((poly) h->Data());
3070  h = h->next;
3071  poly g = pCopy((poly) h->Data());
3072 
3073  res->rtyp=POLY_CMD;
3074  res->data=(poly) plain_spoly(f,g);
3075  return(FALSE);
3076  }
3077  else
3078  if (strcmp(sys_cmd, "testGB")==0)
3079  {
3080  ideal I = (ideal) h->Data();
3081  h = h->next;
3082  ideal GI = (ideal) h->Data();
3083  res->rtyp = INT_CMD;
3084  res->data = (void *)(long) testGB(I, GI);
3085  return(FALSE);
3086  }
3087  else
3088  #endif
3089  /*==================== sca:AltVar ==================================*/
3090  #ifdef HAVE_PLURAL
3091  if ( (strcmp(sys_cmd, "AltVarStart") == 0) || (strcmp(sys_cmd, "AltVarEnd") == 0) )
3092  {
3093  ring r = currRing;
3094 
3095  if((h!=NULL) && (h->Typ()==RING_CMD)) r = (ring)h->Data(); else
3096  {
3097  WerrorS("`system(\"AltVarStart/End\"[,<ring>])` expected");
3098  return TRUE;
3099  }
3100 
3101  res->rtyp=INT_CMD;
3102 
3103  if (rIsSCA(r))
3104  {
3105  if(strcmp(sys_cmd, "AltVarStart") == 0)
3106  res->data = (void*)(long)scaFirstAltVar(r);
3107  else
3108  res->data = (void*)(long)scaLastAltVar(r);
3109  return FALSE;
3110  }
3111 
3112  WerrorS("`system(\"AltVarStart/End\",<ring>) requires a SCA ring");
3113  return TRUE;
3114  }
3115  else
3116  #endif
3117  /*==================== RatNF, noncomm rational coeffs =================*/
3118  #ifdef HAVE_RATGRING
3119  if (strcmp(sys_cmd, "intratNF") == 0)
3120  {
3121  poly p;
3122  poly *q;
3123  ideal I;
3124  int is, k, id;
3125  if ((h!=NULL) && (h->Typ()==POLY_CMD))
3126  {
3127  p=(poly)h->CopyD();
3128  h=h->next;
3129  // PrintS("poly is done\n");
3130  }
3131  else return TRUE;
3132  if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
3133  {
3134  I=(ideal)h->CopyD();
3135  q = I->m;
3136  h=h->next;
3137  // PrintS("ideal is done\n");
3138  }
3139  else return TRUE;
3140  if ((h!=NULL) && (h->Typ()==INT_CMD))
3141  {
3142  is=(int)((long)(h->Data()));
3143  // res->rtyp=INT_CMD;
3144  // PrintS("int is done\n");
3145  // res->rtyp=IDEAL_CMD;
3146  if (rIsPluralRing(currRing))
3147  {
3148  id = IDELEMS(I);
3149  int *pl=(int*)omAlloc0(IDELEMS(I)*sizeof(int));
3150  for(k=0; k < id; k++)
3151  {
3152  pl[k] = pLength(I->m[k]);
3153  }
3154  PrintS("starting redRat\n");
3155  //res->data = (char *)
3156  redRat(&p, q, pl, (int)IDELEMS(I),is,currRing);
3157  res->data=p;
3158  res->rtyp=POLY_CMD;
3159  // res->data = ncGCD(p,q,currRing);
3160  }
3161  else
3162  {
3163  res->rtyp=POLY_CMD;
3164  res->data=p;
3165  }
3166  }
3167  else return TRUE;
3168  return FALSE;
3169  }
3170  else
3171  /*==================== RatNF, noncomm rational coeffs =================*/
3172  if (strcmp(sys_cmd, "ratNF") == 0)
3173  {
3174  poly p,q;
3175  int is, htype;
3176  if ((h!=NULL) && ( (h->Typ()==POLY_CMD) || (h->Typ()==VECTOR_CMD) ) )
3177  {
3178  p=(poly)h->CopyD();
3179  h=h->next;
3180  htype = h->Typ();
3181  }
3182  else return TRUE;
3183  if ((h!=NULL) && ( (h->Typ()==POLY_CMD) || (h->Typ()==VECTOR_CMD) ) )
3184  {
3185  q=(poly)h->CopyD();
3186  h=h->next;
3187  }
3188  else return TRUE;
3189  if ((h!=NULL) && (h->Typ()==INT_CMD))
3190  {
3191  is=(int)((long)(h->Data()));
3192  res->rtyp=htype;
3193  // res->rtyp=IDEAL_CMD;
3194  if (rIsPluralRing(currRing))
3195  {
3196  res->data = nc_rat_ReduceSpolyNew(q,p,is, currRing);
3197  // res->data = ncGCD(p,q,currRing);
3198  }
3199  else res->data=p;
3200  }
3201  else return TRUE;
3202  return FALSE;
3203  }
3204  else
3205  /*==================== RatSpoly, noncomm rational coeffs =================*/
3206  if (strcmp(sys_cmd, "ratSpoly") == 0)
3207  {
3208  poly p,q;
3209  int is;
3210  if ((h!=NULL) && (h->Typ()==POLY_CMD))
3211  {
3212  p=(poly)h->CopyD();
3213  h=h->next;
3214  }
3215  else return TRUE;
3216  if ((h!=NULL) && (h->Typ()==POLY_CMD))
3217  {
3218  q=(poly)h->CopyD();
3219  h=h->next;
3220  }
3221  else return TRUE;
3222  if ((h!=NULL) && (h->Typ()==INT_CMD))
3223  {
3224  is=(int)((long)(h->Data()));
3225  res->rtyp=POLY_CMD;
3226  // res->rtyp=IDEAL_CMD;
3227  if (rIsPluralRing(currRing))
3228  {
3229  res->data = nc_rat_CreateSpoly(p,q,is,currRing);
3230  // res->data = ncGCD(p,q,currRing);
3231  }
3232  else res->data=p;
3233  }
3234  else return TRUE;
3235  return FALSE;
3236  }
3237  else
3238  #endif // HAVE_RATGRING
3239  /*==================== Rat def =================*/
3240  if (strcmp(sys_cmd, "ratVar") == 0)
3241  {
3242  int start,end;
3243  if ((h!=NULL) && (h->Typ()==POLY_CMD))
3244  {
3245  start=pIsPurePower((poly)h->Data());
3246  h=h->next;
3247  }
3248  else return TRUE;
3249  if ((h!=NULL) && (h->Typ()==POLY_CMD))
3250  {
3251  end=pIsPurePower((poly)h->Data());
3252  h=h->next;
3253  }
3254  else return TRUE;
3255  currRing->real_var_start=start;
3256  currRing->real_var_end=end;
3257  return (start==0)||(end==0)||(start>end);
3258  }
3259  else
3260  /*==================== t-rep-GB ==================================*/
3261  if (strcmp(sys_cmd, "unifastmult")==0)
3262  {
3263  poly f = (poly)h->Data();
3264  h=h->next;
3265  poly g=(poly)h->Data();
3266  res->rtyp=POLY_CMD;
3267  res->data=unifastmult(f,g,currRing);
3268  return(FALSE);
3269  }
3270  else
3271  if (strcmp(sys_cmd, "multifastmult")==0)
3272  {
3273  poly f = (poly)h->Data();
3274  h=h->next;
3275  poly g=(poly)h->Data();
3276  res->rtyp=POLY_CMD;
3277  res->data=multifastmult(f,g,currRing);
3278  return(FALSE);
3279  }
3280  else
3281  if (strcmp(sys_cmd, "mults")==0)
3282  {
3283  res->rtyp=INT_CMD ;
3284  res->data=(void*)(long) Mults();
3285  return(FALSE);
3286  }
3287  else
3288  if (strcmp(sys_cmd, "fastpower")==0)
3289  {
3290  ring r = currRing;
3291  poly f = (poly)h->Data();
3292  h=h->next;
3293  int n=(int)((long)h->Data());
3294  res->rtyp=POLY_CMD ;
3295  res->data=(void*) pFastPower(f,n,r);
3296  return(FALSE);
3297  }
3298  else
3299  if (strcmp(sys_cmd, "normalpower")==0)
3300  {
3301  poly f = (poly)h->Data();
3302  h=h->next;
3303  int n=(int)((long)h->Data());
3304  res->rtyp=POLY_CMD ;
3305  res->data=(void*) pPower(pCopy(f),n);
3306  return(FALSE);
3307  }
3308  else
3309  if (strcmp(sys_cmd, "MCpower")==0)
3310  {
3311  ring r = currRing;
3312  poly f = (poly)h->Data();
3313  h=h->next;
3314  int n=(int)((long)h->Data());
3315  res->rtyp=POLY_CMD ;
3316  res->data=(void*) pFastPowerMC(f,n,r);
3317  return(FALSE);
3318  }
3319  else
3320  if (strcmp(sys_cmd, "bit_subst")==0)
3321  {
3322  ring r = currRing;
3323  poly outer = (poly)h->Data();
3324  h=h->next;
3325  poly inner=(poly)h->Data();
3326  res->rtyp=POLY_CMD ;
3327  res->data=(void*) uni_subst_bits(outer, inner,r);
3328  return(FALSE);
3329  }
3330  else
3331  /*==================== gcd-varianten =================*/
3332  if (strcmp(sys_cmd, "gcd") == 0)
3333  {
3334  if (h==NULL)
3335  {
3336  Print("EZGCD:%d (use EZGCD for gcd of polynomials in char 0)\n",isOn(SW_USE_EZGCD));
3337  Print("EZGCD_P:%d (use EZGCD_P for gcd of polynomials in char p)\n",isOn(SW_USE_EZGCD_P));
3338  Print("CRGCD:%d (use chinese Remainder for gcd of polynomials in char 0)\n",isOn(SW_USE_CHINREM_GCD));
3339  Print("QGCD:%d (use QGCD for gcd of polynomials in alg. ext.)\n",isOn(SW_USE_QGCD));
3340  Print("homog:%d (use homog. test for factorization of polynomials)\n",singular_homog_flag);
3341  return FALSE;
3342  }
3343  else
3344  if ((h!=NULL) && (h->Typ()==STRING_CMD)
3345  && (h->next!=NULL) && (h->next->Typ()==INT_CMD))
3346  {
3347  int d=(int)(long)h->next->Data();
3348  char *s=(char *)h->Data();
3349 #ifdef HAVE_PLURAL
3350  if (strcmp(s,"EZGCD")==0) { if (d) On(SW_USE_EZGCD); else Off(SW_USE_EZGCD); } else
3351  if (strcmp(s,"EZGCD_P")==0) { if (d) On(SW_USE_EZGCD_P); else Off(SW_USE_EZGCD_P); } else
3352  if (strcmp(s,"CRGCD")==0) { if (d) On(SW_USE_CHINREM_GCD); else Off(SW_USE_CHINREM_GCD); } else
3353  if (strcmp(s,"QGCD")==0) { if (d) On(SW_USE_QGCD); else Off(SW_USE_QGCD); } else
3354 #endif
3355  if (strcmp(s,"homog")==0) { if (d) singular_homog_flag=1; else singular_homog_flag=0; } else
3356  return TRUE;
3357  return FALSE;
3358  }
3359  else return TRUE;
3360  }
3361  else
3362  /*==================== subring =================*/
3363  if (strcmp(sys_cmd, "subring") == 0)
3364  {
3365  if (h!=NULL)
3366  {
3367  extern ring rSubring(ring r,leftv v); /* ipshell.cc*/
3368  res->data=(char *)rSubring(currRing,h);
3369  res->rtyp=RING_CMD;
3370  return res->data==NULL;
3371  }
3372  else return TRUE;
3373  }
3374  else
3375  /*==================== HNF =================*/
3376  #ifdef HAVE_NTL
3377  if (strcmp(sys_cmd, "HNF") == 0)
3378  {
3379  if (h!=NULL)
3380  {
3381  res->rtyp=h->Typ();
3382  if (h->Typ()==MATRIX_CMD)
3383  {
3384  res->data=(char *)singntl_HNF((matrix)h->Data(), currRing);
3385  return FALSE;
3386  }
3387  else if (h->Typ()==INTMAT_CMD)
3388  {
3389  res->data=(char *)singntl_HNF((intvec*)h->Data());
3390  return FALSE;
3391  }
3392  else if (h->Typ()==INTMAT_CMD)
3393  {
3394  res->data=(char *)singntl_HNF((intvec*)h->Data());
3395  return FALSE;
3396  }
3397  else
3398  {
3399  WerrorS("expected `system(\"HNF\",<matrix|intmat|bigintmat>)`");
3400  return TRUE;
3401  }
3402  }
3403  else return TRUE;
3404  }
3405  else
3406  /*================= probIrredTest ======================*/
3407  if (strcmp (sys_cmd, "probIrredTest") == 0)
3408  {
3409  if (h!=NULL && (h->Typ()== POLY_CMD) && ((h->next != NULL) && h->next->Typ() == STRING_CMD))
3410  {
3411  CanonicalForm F= convSingPFactoryP((poly)(h->Data()), currRing);
3412  char *s=(char *)h->next->Data();
3413  double error= atof (s);
3414  int irred= probIrredTest (F, error);
3415  res->rtyp= INT_CMD;
3416  res->data= (void*)(long)irred;
3417  return FALSE;
3418  }
3419  else return TRUE;
3420  }
3421  else
3422  #endif
3423  /*==================== mpz_t loader ======================*/
3424  if(strcmp(sys_cmd, "GNUmpLoad")==0)
3425  {
3426  if ((h != NULL) && (h->Typ() == STRING_CMD))
3427  {
3428  char* filename = (char*)h->Data();
3429  FILE* f = fopen(filename, "r");
3430  if (f == NULL)
3431  {
3432  WerrorS( "invalid file name (in paths use '/')");
3433  return FALSE;
3434  }
3435  mpz_t m; mpz_init(m);
3436  mpz_inp_str(m, f, 10);
3437  fclose(f);
3438  number n = n_InitMPZ(m, coeffs_BIGINT);
3439  res->rtyp = BIGINT_CMD;
3440  res->data = (void*)n;
3441  return FALSE;
3442  }
3443  else
3444  {
3445  WerrorS( "expected valid file name as a string");
3446  return TRUE;
3447  }
3448  }
3449  else
3450  /*==================== intvec matching ======================*/
3451  /* Given two non-empty intvecs, the call
3452  'system("intvecMatchingSegments", ivec, jvec);'
3453  computes all occurences of jvec in ivec, i.e., it returns
3454  a list of int indices k such that ivec[k..size(jvec)+k-1] = jvec.
3455  If no such k exists (e.g. when ivec is shorter than jvec), an
3456  intvec with the single entry 0 is being returned. */
3457  if(strcmp(sys_cmd, "intvecMatchingSegments")==0)
3458  {
3459  if ((h != NULL) && (h->Typ() == INTVEC_CMD) &&
3460  (h->next != NULL) && (h->next->Typ() == INTVEC_CMD) &&
3461  (h->next->next == NULL))
3462  {
3463  intvec* ivec = (intvec*)h->Data();
3464  intvec* jvec = (intvec*)h->next->Data();
3465  intvec* r = new intvec(1); (*r)[0] = 0;
3466  int validEntries = 0;
3467  for (int k = 0; k <= ivec->rows() - jvec->rows(); k++)
3468  {
3469  if (memcmp(&(*ivec)[k], &(*jvec)[0],
3470  sizeof(int) * jvec->rows()) == 0)
3471  {
3472  if (validEntries == 0)
3473  (*r)[0] = k + 1;
3474  else
3475  {
3476  r->resize(validEntries + 1);
3477  (*r)[validEntries] = k + 1;
3478  }
3479  validEntries++;
3480  }
3481  }
3482  res->rtyp = INTVEC_CMD;
3483  res->data = (void*)r;
3484  return FALSE;
3485  }
3486  else
3487  {
3488  WerrorS("expected two non-empty intvecs as arguments");
3489  return TRUE;
3490  }
3491  }
3492  else
3493  /* ================== intvecOverlap ======================= */
3494  /* Given two non-empty intvecs, the call
3495  'system("intvecOverlap", ivec, jvec);'
3496  computes the longest intvec kvec such that ivec ends with kvec
3497  and jvec starts with kvec. The length of this overlap is being
3498  returned. If there is no overlap at all, then 0 is being returned. */
3499  if(strcmp(sys_cmd, "intvecOverlap")==0)
3500  {
3501  if ((h != NULL) && (h->Typ() == INTVEC_CMD) &&
3502  (h->next != NULL) && (h->next->Typ() == INTVEC_CMD) &&
3503  (h->next->next == NULL))
3504  {
3505  intvec* ivec = (intvec*)h->Data();
3506  intvec* jvec = (intvec*)h->next->Data();
3507  int ir = ivec->rows(); int jr = jvec->rows();
3508  int r = jr; if (ir < jr) r = ir; /* r = min{ir, jr} */
3509  while ((r >= 1) && (memcmp(&(*ivec)[ir - r], &(*jvec)[0],
3510  sizeof(int) * r) != 0))
3511  r--;
3512  res->rtyp = INT_CMD;
3513  res->data = (void*)(long)r;
3514  return FALSE;
3515  }
3516  else
3517  {
3518  WerrorS("expected two non-empty intvecs as arguments");
3519  return TRUE;
3520  }
3521  }
3522  else
3523  /*==================== Hensel's lemma ======================*/
3524  if(strcmp(sys_cmd, "henselfactors")==0)
3525  {
3526  if ((h != NULL) && (h->Typ() == INT_CMD) &&
3527  (h->next != NULL) && (h->next->Typ() == INT_CMD) &&
3528  (h->next->next != NULL) && (h->next->next->Typ() == POLY_CMD) &&
3529  (h->next->next->next != NULL) &&
3530  (h->next->next->next->Typ() == POLY_CMD) &&
3531  (h->next->next->next->next != NULL) &&
3532  (h->next->next->next->next->Typ() == POLY_CMD) &&
3533  (h->next->next->next->next->next != NULL) &&
3534  (h->next->next->next->next->next->Typ() == INT_CMD) &&
3535  (h->next->next->next->next->next->next == NULL))
3536  {
3537  int xIndex = (int)(long)h->Data();
3538  int yIndex = (int)(long)h->next->Data();
3539  poly hh = (poly)h->next->next->Data();
3540  poly f0 = (poly)h->next->next->next->Data();
3541  poly g0 = (poly)h->next->next->next->next->Data();
3542  int d = (int)(long)h->next->next->next->next->next->Data();
3543  poly f; poly g;
3544  henselFactors(xIndex, yIndex, hh, f0, g0, d, f, g);
3546  L->Init(2);
3547  L->m[0].rtyp = POLY_CMD; L->m[0].data=(void*)f;
3548  L->m[1].rtyp = POLY_CMD; L->m[1].data=(void*)g;
3549  res->rtyp = LIST_CMD;
3550  res->data = (char *)L;
3551  return FALSE;
3552  }
3553  else
3554  {
3555  WerrorS( "expected argument list (int, int, poly, poly, poly, int)");
3556  return TRUE;
3557  }
3558  }
3559  else
3560  /*==================== Approx_Step =================*/
3561  #ifdef HAVE_PLURAL
3562  if (strcmp(sys_cmd, "astep") == 0)
3563  {
3564  ideal I;
3565  if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
3566  {
3567  I=(ideal)h->CopyD();
3568  res->rtyp=IDEAL_CMD;
3569  if (rIsPluralRing(currRing)) res->data=Approx_Step(I);
3570  else res->data=I;
3571  setFlag(res,FLAG_STD);
3572  }
3573  else return TRUE;
3574  return FALSE;
3575  }
3576  else
3577  #endif
3578  /*==================== PrintMat =================*/
3579  #ifdef HAVE_PLURAL
3580  if (strcmp(sys_cmd, "PrintMat") == 0)
3581  {
3582  int a;
3583  int b;
3584  ring r;
3585  int metric;
3586  if (h!=NULL)
3587  {
3588  if (h->Typ()==INT_CMD)
3589  {
3590  a=(int)((long)(h->Data()));
3591  h=h->next;
3592  }
3593  else if (h->Typ()==INT_CMD)
3594  {
3595  b=(int)((long)(h->Data()));
3596  h=h->next;
3597  }
3598  else if (h->Typ()==RING_CMD)
3599  {
3600  r=(ring)h->Data();
3601  h=h->next;
3602  }
3603  else
3604  return TRUE;
3605  }
3606  else
3607  return TRUE;
3608  if ((h!=NULL) && (h->Typ()==INT_CMD))
3609  {
3610  metric=(int)((long)(h->Data()));
3611  }
3612  res->rtyp=MATRIX_CMD;
3613  if (rIsPluralRing(r)) res->data=nc_PrintMat(a,b,r,metric);
3614  else res->data=NULL;
3615  return FALSE;
3616  }
3617  else
3618  #endif
3619 /* ============ NCUseExtensions ======================== */
3620  #ifdef HAVE_PLURAL
3621  if(strcmp(sys_cmd,"NCUseExtensions")==0)
3622  {
3623  if ((h!=NULL) && (h->Typ()==INT_CMD))
3624  res->data=(void *)(long)setNCExtensions( (int)((long)(h->Data())) );
3625  else
3626  res->data=(void *)(long)getNCExtensions();
3627  res->rtyp=INT_CMD;
3628  return FALSE;
3629  }
3630  else
3631  #endif
3632 /* ============ NCGetType ======================== */
3633  #ifdef HAVE_PLURAL
3634  if(strcmp(sys_cmd,"NCGetType")==0)
3635  {
3636  res->rtyp=INT_CMD;
3637  if( rIsPluralRing(currRing) )
3638  res->data=(void *)(long)ncRingType(currRing);
3639  else
3640  res->data=(void *)(-1L);
3641  return FALSE;
3642  }
3643  else
3644  #endif
3645 /* ============ ForceSCA ======================== */
3646  #ifdef HAVE_PLURAL
3647  if(strcmp(sys_cmd,"ForceSCA")==0)
3648  {
3649  if( !rIsPluralRing(currRing) )
3650  return TRUE;
3651  int b, e;
3652  if ((h!=NULL) && (h->Typ()==INT_CMD))
3653  {
3654  b = (int)((long)(h->Data()));
3655  h=h->next;
3656  }
3657  else return TRUE;
3658  if ((h!=NULL) && (h->Typ()==INT_CMD))
3659  {
3660  e = (int)((long)(h->Data()));
3661  }
3662  else return TRUE;
3663  if( !sca_Force(currRing, b, e) )
3664  return TRUE;
3665  return FALSE;
3666  }
3667  else
3668  #endif
3669 /* ============ ForceNewNCMultiplication ======================== */
3670  #ifdef HAVE_PLURAL
3671  if(strcmp(sys_cmd,"ForceNewNCMultiplication")==0)
3672  {
3673  if( !rIsPluralRing(currRing) )
3674  return TRUE;
3675  if( !ncInitSpecialPairMultiplication(currRing) ) // No Plural!
3676  return TRUE;
3677  return FALSE;
3678  }
3679  else
3680  #endif
3681 /* ============ ForceNewOldNCMultiplication ======================== */
3682  #ifdef HAVE_PLURAL
3683  if(strcmp(sys_cmd,"ForceNewOldNCMultiplication")==0)
3684  {
3685  if( !rIsPluralRing(currRing) )
3686  return TRUE;
3687  if( !ncInitSpecialPowersMultiplication(currRing) ) // Enable Formula for Plural (depends on swiches)!
3688  return TRUE;
3689  return FALSE;
3690  }
3691  else
3692  #endif
3693 /*==================== test64 =================*/
3694  #if 0
3695  if(strcmp(sys_cmd,"test64")==0)
3696  {
3697  long l=8;int i;
3698  for(i=1;i<62;i++)
3699  {
3700  l=l<<1;
3701  number n=n_Init(l,coeffs_BIGINT);
3702  Print("%ld= ",l);n_Print(n,coeffs_BIGINT);
3704  n_Delete(&n,coeffs_BIGINT);
3706  PrintS(" F:");
3708  PrintLn();
3709  n_Delete(&n,coeffs_BIGINT);
3710  }
3711  Print("SIZEOF_LONG=%d\n",SIZEOF_LONG);
3712  return FALSE;
3713  }
3714  else
3715  #endif
3716 /*==================== n_SwitchChinRem =================*/
3717  if(strcmp(sys_cmd,"cache_chinrem")==0)
3718  {
3719  extern int n_SwitchChinRem;
3720  Print("caching inverse in chines remainder:%d\n",n_SwitchChinRem);
3721  if ((h!=NULL)&&(h->Typ()==INT_CMD))
3722  n_SwitchChinRem=(int)(long)h->Data();
3723  return FALSE;
3724  }
3725  else
3726 /*==================== LU for bigintmat =================*/
3727 #ifdef SINGULAR_4_2
3728  if(strcmp(sys_cmd,"LU")==0)
3729  {
3730  if ((h!=NULL) && (h->Typ()==CMATRIX_CMD))
3731  {
3732  // get the argument:
3733  bigintmat *b=(bigintmat *)h->Data();
3734  // just for tests: simply transpose
3735  bigintmat *bb=b->transpose();
3736  // return the result:
3737  res->rtyp=CMATRIX_CMD;
3738  res->data=(char*)bb;
3739  return FALSE;
3740  }
3741  else
3742  {
3743  WerrorS("system(\"LU\",<cmatrix>) expected");
3744  return TRUE;
3745  }
3746  }
3747  else
3748 #endif
3749 /*==================== sort =================*/
3750  if(strcmp(sys_cmd,"sort")==0)
3751  {
3752  extern BOOLEAN jjSORTLIST(leftv,leftv);
3753  if (h->Typ()==LIST_CMD)
3754  return jjSORTLIST(res,h);
3755  else
3756  return TRUE;
3757  }
3758  else
3759 /*==================== uniq =================*/
3760  if(strcmp(sys_cmd,"uniq")==0)
3761  {
3762  extern BOOLEAN jjUNIQLIST(leftv, leftv);
3763  if (h->Typ()==LIST_CMD)
3764  return jjUNIQLIST(res,h);
3765  else
3766  return TRUE;
3767  }
3768  else
3769 /*==================== tensor =================*/
3770  if(strcmp(sys_cmd,"tensor")==0)
3771  {
3772  const short t[]={2,MODUL_CMD,MODUL_CMD};
3773  if (iiCheckTypes(h,t,1))
3774  {
3775  res->data=(void*)mp_Tensor((ideal)h->Data(),(ideal)h->next->Data(),currRing);
3776  res->rtyp=MODUL_CMD;
3777  return FALSE;
3778  }
3779  else
3780  return TRUE;
3781  }
3782  else
3783 /*==================== GF(p,n) ==================================*/
3784  if(strcmp(sys_cmd,"GF")==0)
3785  {
3786  const short t[]={3,INT_CMD,INT_CMD,STRING_CMD};
3787  if (iiCheckTypes(h,t,1))
3788  {
3789  int p=(int)(long)h->Data();
3790  int n=(int)(long)h->next->Data();
3791  char *v=(char*)h->next->next->CopyD();
3792  GFInfo param;
3793  param.GFChar = p;
3794  param.GFDegree = n;
3795  param.GFPar_name = v;
3796  coeffs cf= nInitChar(n_GF, &param);
3797  res->rtyp=CRING_CMD;
3798  res->data=cf;
3799  return FALSE;
3800  }
3801  else
3802  return TRUE;
3803  }
3804  else
3805 /*==================== power* ==================================*/
3806  #if 0
3807  if(strcmp(sys_cmd,"power1")==0)
3808  {
3809  res->rtyp=POLY_CMD;
3810  poly f=(poly)h->CopyD();
3811  poly g=pPower(f,2000);
3812  res->data=(void *)g;
3813  return FALSE;
3814  }
3815  else
3816  if(strcmp(sys_cmd,"power2")==0)
3817  {
3818  res->rtyp=POLY_CMD;
3819  poly f=(poly)h->Data();
3820  poly g=pOne();
3821  for(int i=0;i<2000;i++)
3822  g=pMult(g,pCopy(f));
3823  res->data=(void *)g;
3824  return FALSE;
3825  }
3826  if(strcmp(sys_cmd,"power3")==0)
3827  {
3828  res->rtyp=POLY_CMD;
3829  poly f=(poly)h->Data();
3830  poly p2=pMult(pCopy(f),pCopy(f));
3831  poly p4=pMult(pCopy(p2),pCopy(p2));
3832  poly p8=pMult(pCopy(p4),pCopy(p4));
3833  poly p16=pMult(pCopy(p8),pCopy(p8));
3834  poly p32=pMult(pCopy(p16),pCopy(p16));
3835  poly p64=pMult(pCopy(p32),pCopy(p32));
3836  poly p128=pMult(pCopy(p64),pCopy(p64));
3837  poly p256=pMult(pCopy(p128),pCopy(p128));
3838  poly p512=pMult(pCopy(p256),pCopy(p256));
3839  poly p1024=pMult(pCopy(p512),pCopy(p512));
3840  poly p1536=pMult(p1024,p512);
3841  poly p1792=pMult(p1536,p256);
3842  poly p1920=pMult(p1792,p128);
3843  poly p1984=pMult(p1920,p64);
3844  poly p2000=pMult(p1984,p16);
3845  res->data=(void *)p2000;
3846  pDelete(&p2);
3847  pDelete(&p4);
3848  pDelete(&p8);
3849  //pDelete(&p16);
3850  pDelete(&p32);
3851  //pDelete(&p64);
3852  //pDelete(&p128);
3853  //pDelete(&p256);
3854  //pDelete(&p512);
3855  //pDelete(&p1024);
3856  //pDelete(&p1536);
3857  //pDelete(&p1792);
3858  //pDelete(&p1920);
3859  //pDelete(&p1984);
3860  return FALSE;
3861  }
3862  else
3863  #endif
3864 /*==================== Error =================*/
3865  Werror( "(extended) system(\"%s\",...) %s", sys_cmd, feNotImplemented );
3866  }
3867  return TRUE;
3868 }
3869 
3870 #endif // HAVE_EXTENDED_SYSTEM
3871 
3872 
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
dim
int dim(ideal I, ring r)
Definition: tropicalStrategy.cc:22
AEp.h
pDivisibleBy
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
Definition: polys.h:132
FALSE
#define FALSE
Definition: auxiliary.h:94
kFindZeroPoly
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
Definition: kstd2.cc:324
ivTest
#define ivTest(v)
Definition: intvec.h:155
jjUNIQLIST
BOOLEAN jjUNIQLIST(leftv, leftv arg)
Definition: iparith.cc:9369
mod_raw.h
omPrintUsedTrackAddrs
void omPrintUsedTrackAddrs(FILE *fd, int max_frames)
Definition: omDebugCheck.c:571
pLmDeleteAndNext
#define pLmDeleteAndNext(p)
like pLmDelete, returns pNext(p)
Definition: polys.h:76
error
void error(const char *fmt,...)
Definition: emacs.cc:54
matrix
ip_smatrix * matrix
Definition: matpol.h:30
hutil.h
ncInitSpecialPairMultiplication
BOOLEAN ncInitSpecialPairMultiplication(ring r)
Definition: ncSAMult.cc:263
sleftv::Data
void * Data()
Definition: subexpr.cc:1133
countedref_shared_load
void countedref_shared_load()
Definition: countedref.cc:724
rField_is_long_R
static BOOLEAN rField_is_long_R(const ring r)
Definition: ring.h:533
GFInfo::GFChar
int GFChar
Definition: coeffs.h:94
twostd
ideal twostd(ideal I)
Compute two-sided GB:
Definition: nc.cc:18
fePrintOptValues
void fePrintOptValues()
Definition: feOpt.cc:315
getenv
char * getenv()
mpr_complex.h
feReInitResources
void feReInitResources()
Definition: feResource.cc:204
p_GetCoeff
#define p_GetCoeff(p, r)
Definition: monomials.h:54
TranMImprovwalk
ideal TranMImprovwalk(ideal G, intvec *curr_weight, intvec *target_tmp, int nP)
Definition: walk.cc:8326
multifastmult
poly multifastmult(poly f, poly g, ring r)
Definition: fast_mult.cc:290
ip_smatrix
Definition: matpol.h:13
isOn
bool isOn(int sw)
switches
Definition: canonicalform.cc:1912
kutil.h
Mwalk
ideal Mwalk(ideal Go, intvec *orig_M, intvec *target_M, ring baseRing, int reduction, int printout)
Definition: walk.cc:5239
FLAG_TWOSTD
#define FLAG_TWOSTD
Definition: ipid.h:104
j
int j
Definition: facHensel.cc:105
versionString
char * versionString()
Definition: misc_ip.cc:788
f
FILE * f
Definition: checklibs.c:9
posInT17_c
int posInT17_c(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5737
spectrumfProc
BOOLEAN spectrumfProc(leftv result, leftv first)
Definition: ipshell.cc:4121
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
gmp_output_digits
size_t gmp_output_digits
Definition: mpr_complex.cc:42
k
int k
Definition: cfEzgcd.cc:92
CRING_CMD
Definition: tok.h:55
gmsNF
lists gmsNF(ideal p, ideal g, matrix B, int D, int K)
Definition: gms.cc:21
rDebugPrint
void rDebugPrint(const ring r)
Definition: ring.cc:3997
NUMBER_CMD
Definition: grammar.cc:287
procinfov
procinfo * procinfov
Definition: structs.h:62
MATELEM
#define MATELEM(mat, i, j)
Definition: matpol.h:28
newstruct.h
bigintmat
Definition: bigintmat.h:50
fglmNewLinearCombination
poly fglmNewLinearCombination(ideal source, poly monset)
Definition: fglmcomb.cc:154
nc_rat_ReduceSpolyNew
poly nc_rat_ReduceSpolyNew(const poly p1, poly p2, int ishift, const ring r)
Definition: ratgring.cc:465
nc_p_Bracket_qq
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
Definition: old.gring.cc:2242
result
return result
Definition: facAbsBiFact.cc:76
n_GetChar
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
GFInfo
Creation data needed for finite fields.
Definition: coeffs.h:92
p_DebugPrint
void p_DebugPrint(poly p, const ring r)
Definition: ring.cc:4202
BIGINT_CMD
Definition: tok.h:37
LIST_CMD
Definition: tok.h:117
pGetExp
#define pGetExp(p, i)
Exponent.
Definition: polys.h:40
evRowElim
matrix evRowElim(matrix M, int i, int j, int k)
Definition: eigenval.cc:47
posInT_EcartFDegpLength
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11449
eigenval_ip.h
Mivdp
intvec * Mivdp(int nR)
Definition: walk.cc:983
lists.h
attrib.h
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
posInT17
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5630
MODUL_CMD
Definition: grammar.cc:286
MwalkNextWeight
intvec * MwalkNextWeight(intvec *curr_weight, intvec *target_weight, ideal G)
STRING_CMD
Definition: tok.h:182
feOptIndex
feOptIndex
Definition: feOptGen.h:14
redRat
int redRat(poly *h, poly *reducer, int *red_length, int rl, int ishift, ring r)
Definition: ratgring.cc:593
MPertVectorslp
intvec * MPertVectorslp(ideal G, intvec *ivtarget, int pdeg)
Definition: walk.cc:1271
ncRingType
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:167
M3ivSame
int M3ivSame(intvec *temp, intvec *u, intvec *v)
Definition: walk.cc:895
feOpt.h
feGetOptIndex
feOptIndex feGetOptIndex(const char *name)
Definition: feOpt.cc:100
NONE
#define NONE
Definition: tok.h:217
irred
CFList int bool & irred
[in,out] Is A irreducible?
Definition: facFactorize.h:31
points
static coordinates * points
Definition: interpolation.cc:96
fehelp.h
weight.h
cf
CanonicalForm cf
Definition: cfModGcd.cc:4024
ppJetW
#define ppJetW(p, m, iv)
Definition: polys.h:343
freegb
ideal freegb(ideal I, int uptodeg, int lVblock)
Definition: kstd2.cc:4230
omError2String
const char * omError2String(omError_t error)
Definition: omError.c:51
polys.h
IDDATA
#define IDDATA(a)
Definition: ipid.h:120
feOptUntyped
Definition: fegetopt.h:77
pFastPowerMC
poly pFastPowerMC(poly f, int n, ring r)
Definition: fast_mult.cc:588
posInT110
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5378
ip_smatrix::cols
int & cols()
Definition: matpol.h:24
iv2array
short * iv2array(intvec *iv, const ring R)
Definition: weight.cc:205
length
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:267
procinfo
Definition: subexpr.h:52
Mpwalk
ideal Mpwalk(ideal Go, int op_deg, int tp_deg, intvec *curr_weight, intvec *target_weight, int nP, int reduction, int printout)
Definition: walk.cc:5884
fast_mult.h
tgb.h
g
g
Definition: cfModGcd.cc:4031
MivUnit
intvec * MivUnit(int nV)
Definition: walk.cc:1464
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
omFindExec.h
AE.h
spmulProc
BOOLEAN spmulProc(leftv result, leftv first, leftv second)
Definition: ipshell.cc:4407
feSetOptValue
const char * feSetOptValue(feOptIndex opt, char *optarg)
Definition: feOpt.cc:149
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
DEF_CMD
Definition: tok.h:57
n_GF
\GF{p^n < 2^16}
Definition: coeffs.h:32
clapconv.h
nInitChar
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:349
omAllocBin
#define omAllocBin(bin)
Definition: omAllocDecl.h:203
options.h
feStringAppendBrowsers
void feStringAppendBrowsers(int warn)
Definition: fehelp.cc:340
jjSORTLIST
BOOLEAN jjSORTLIST(leftv, leftv arg)
Definition: iparith.cc:9360
BIGINTMAT_CMD
Definition: grammar.cc:278
semicProc3
BOOLEAN semicProc3(leftv res, leftv u, leftv v, leftv w)
Definition: ipshell.cc:4448
sdb_edit
void sdb_edit(procinfo *pi)
Definition: sdb.cc:109
pDelete
#define pDelete(p_ptr)
Definition: polys.h:166
getNCExtensions
int & getNCExtensions()
Definition: old.gring.cc:82
testHomog
Definition: structs.h:40
pyobject_setup.h
mp_Tensor
ideal mp_Tensor(ideal A, ideal B, const ring r)
Definition: matpol.cc:1747
StringEndS
char * StringEndS()
Definition: reporter.cc:150
pcvBasis
int pcvBasis(lists b, int i, poly m, int d, int n)
Definition: pcv.cc:390
printBlackboxTypes
void printBlackboxTypes()
list all defined type (for debugging)
Definition: blackbox.cc:209
setNCExtensions
int setNCExtensions(int iMask)
Definition: old.gring.cc:87
siRandomStart
int siRandomStart
Definition: cntrlc.cc:98
posInT_FDegpLength
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11503
kNFBound
poly kNFBound(ideal F, ideal Q, poly p, int bound, int syzComp, int lazyReduce)
Definition: kstd1.cc:2858
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:81
pMult
#define pMult(p, q)
Definition: polys.h:186
testGB
int testGB(ideal I, ideal GI)
Definition: ringgb.cc:226
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
pcvMinDeg
int pcvMinDeg(poly p)
Definition: pcv.cc:107
RING_CMD
Definition: grammar.cc:281
b
CanonicalForm b
Definition: cfModGcd.cc:4044
pFastPower
poly pFastPower(poly f, int n, ring r)
Definition: fast_mult.cc:342
n_InitMPZ
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition: coeffs.h:542
bigintmat.h
currRingHdl
idhdl currRingHdl
Definition: ipid.cc:60
slists_bin
omBin slists_bin
Definition: lists.cc:22
evSwap
matrix evSwap(matrix M, int i, int j)
Definition: eigenval.cc:25
omPrintCurrentBackTrace
#define omPrintCurrentBackTrace(fd)
Definition: omRet2Info.h:38
pOppose
poly pOppose(ring Rop_src, poly p, const ring Rop_dst)
opposes a vector p from Rop to currRing (dst!)
Definition: old.gring.cc:3367
MATRIX_CMD
Definition: grammar.cc:285
testsvd
lists testsvd(matrix M)
Definition: calcSVD.cc:26
longCoeffsToSingularPoly
poly longCoeffsToSingularPoly(unsigned long *polyCoeffs, const int degree)
Definition: extra.cc:205
CanonicalForm
factory's main class
Definition: canonicalform.h:77
posInT19
int posInT19(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5864
factoryseed
void factoryseed(int s)
random seed initializer
Definition: cf_random.cc:176
term
Definition: int_poly.h:33
test_PosInL
int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd2.cc:81
p_SetExp
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:476
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:403
pLength
static unsigned pLength(poly a)
Definition: p_polys.h:183
HilbertSeries_OrbitData
void HilbertSeries_OrbitData(ideal S, int lV, bool IG_CASE, bool mgrad, bool odp, int trunDegHs)
Definition: hilb.cc:1968
SW_USE_EZGCD
static const int SW_USE_EZGCD
set to 1 to use EZGCD over Z
Definition: cf_defs.h:32
sca_Force
bool sca_Force(ring rGR, int b, int e)
Definition: sca.cc:1159
get_denom_list
lists get_denom_list()
Definition: denom_list.cc:8
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
digitech.h
stairc.h
MAltwalk2
ideal MAltwalk2(ideal Go, intvec *curr_weight, intvec *target_weight)
Definition: walk.cc:4221
om_InternalErrorStatus
omError_t om_InternalErrorStatus
Definition: omError.c:11
test_PosInT
int(* test_PosInT)(const TSet T, const int tl, LObject &h)
Definition: kstd2.cc:80
omError2Serror
const char * omError2Serror(omError_t error)
Definition: omError.c:62
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
rChar
int rChar(ring r)
Definition: ring.cc:687
ip_smatrix::rows
int & rows()
Definition: matpol.h:23
res
CanonicalForm res
Definition: facAbsFact.cc:64
INT_CMD
Definition: tok.h:95
countedref_reference_load
void countedref_reference_load()
Initialize blackbox types 'reference' and 'shared', or both.
Definition: countedref.cc:700
matpol.h
Mprwalk
ideal Mprwalk(ideal Go, intvec *orig_M, intvec *target_M, int weight_rad, int op_deg, int tp_deg, int nP, int reduction, int printout)
Definition: walk.cc:6324
Sy_bit
#define Sy_bit(x)
Definition: options.h:31
M
#define M
Definition: sirandom.c:24
n_convFactoryNSingN
number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: numbers.cc:592
posInT2
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5195
PrintS
void PrintS(const char *s)
Definition: reporter.cc:283
pcvPMulL
lists pcvPMulL(poly p, lists l1)
Definition: pcv.cc:55
luSolveViaLDUDecomp
bool luSolveViaLDUDecomp(const matrix pMat, const matrix lMat, const matrix dMat, const matrix uMat, const poly l, const poly u, const poly lTimesU, const matrix bVec, matrix &xVec, matrix &H)
Solves the linear system A * x = b, where A is an (m x n)-matrix which is given by its LDU-decomposit...
Definition: linearAlgebra.cc:1461
ringgb.h
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
Mivperttarget
intvec * Mivperttarget(ideal G, int ndeg)
walk.h
lduDecomp
void lduDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &dMat, matrix &uMat, poly &l, poly &u, poly &lTimesU)
LU-decomposition of a given (m x n)-matrix with performing only those divisions that yield zero remai...
Definition: linearAlgebra.cc:1343
f5gb.h
PROC_CMD
Definition: grammar.cc:280
MivSame
int MivSame(intvec *u, intvec *v)
Definition: walk.cc:875
clapsing.h
createG0
ideal createG0()
Definition: kutil.cc:4388
simpleipc.h
om_ErrorStatus
omError_t om_ErrorStatus
Definition: omError.c:10
posInT_pLength
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11540
T
static jList * T
Definition: janet.cc:31
mp_Transp
matrix mp_Transp(matrix a, const ring R)
Definition: matpol.cc:255
Mfwalk
ideal Mfwalk(ideal G, intvec *ivstart, intvec *ivtarget, int reduction, int printout)
Definition: walk.cc:7963
scaFirstAltVar
static short scaFirstAltVar(ring r)
Definition: sca.h:18
rField_is_Ring
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:476
henselFactors
void henselFactors(const int xIndex, const int yIndex, const poly h, const poly f0, const poly g0, const int d, poly &f, poly &g)
Computes a factorization of a polynomial h(x, y) in K[[x]][y] up to a certain degree in x,...
Definition: linearAlgebra.cc:1219
rOpposite
ring rOpposite(ring src)
Definition: ring.cc:5175
nfMinPoly
static int nfMinPoly[16]
Definition: ffields.cc:562
IDEAL_CMD
Definition: grammar.cc:283
RightColonOperation
ideal RightColonOperation(ideal S, poly w, int lV)
Definition: hilb.cc:2308
misc_ip.h
pcvCV2P
poly pcvCV2P(poly cv, int d0, int d1)
Definition: pcv.cc:262
h
static Poly * h
Definition: janet.cc:972
semicProc
BOOLEAN semicProc(leftv res, leftv u, leftv v)
Definition: ipshell.cc:4488
mod2.h
sca.h
GFInfo::GFDegree
int GFDegree
Definition: coeffs.h:95
setCharacteristic
void setCharacteristic(int c)
Definition: cf_char.cc:23
cntrlc.h
singular_homog_flag
int singular_homog_flag
Definition: cf_factor.cc:377
max
static int max(int a, int b)
Definition: fast_mult.cc:264
coeffs
pOne
#define pOne()
Definition: polys.h:289
MivMatrixOrderdp
intvec * MivMatrixOrderdp(int nV)
Definition: walk.cc:1387
intvec
Definition: intvec.h:16
blackbox.h
blackboxIsCmd
int blackboxIsCmd(const char *n, int &tok)
used by scanner: returns ROOT_DECL for known types (and the type number in tok)
Definition: blackbox.cc:192
sleftv::data
void * data
Definition: subexpr.h:87
Mults
int Mults()
Definition: fast_mult.cc:14
pIter
#define pIter(p)
Definition: monomials.h:41
intvec::resize
void resize(int new_length)
Definition: intvec.cc:105
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
shiftgb.h
spaddProc
BOOLEAN spaddProc(leftv result, leftv first, leftv second)
Definition: ipshell.cc:4365
singntl_HNF
matrix singntl_HNF(matrix m, const ring s)
Definition: clapsing.cc:1698
F5main
ideal F5main(ideal id, ring r, int opt, int plus, int termination)
Definition: f5gb.cc:1890
SW_USE_CHINREM_GCD
static const int SW_USE_CHINREM_GCD
set to 1 to use modular gcd over Z
Definition: cf_defs.h:38
n_Init
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
GFInfo::GFPar_name
const char * GFPar_name
Definition: coeffs.h:96
SINGULAR_VERSION
#define SINGULAR_VERSION
Definition: mod2.h:85
VECTOR_CMD
Definition: grammar.cc:290
myynest
int myynest
Definition: febase.cc:40
pp
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:253
singularMatrixToLongMatrix
unsigned long ** singularMatrixToLongMatrix(matrix singularMatrix)
Definition: extra.cc:173
maps.h
slists::m
sleftv * m
Definition: lists.h:44
MivMatrixOrder
intvec * MivMatrixOrder(intvec *iv)
Definition: walk.cc:941
pPower
#define pPower(p, q)
Definition: polys.h:183
rBlocks
static int rBlocks(ring r)
Definition: ring.h:558
ipconv.h
uni_subst_bits
poly uni_subst_bits(poly outer_uni, poly inner_multi, ring r)
Definition: digitech.cc:47
omFindExec
char * omFindExec(const char *name, char *exec)
Definition: omFindExec.c:251
MivWeightOrderdp
intvec * MivWeightOrderdp(intvec *ivstart)
Definition: walk.cc:1424
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:35
n_convSingNFactoryN
CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: numbers.cc:597
ksOldSpolyRed
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
Definition: kInline.h:1049
pAdd
#define pAdd(p, q)
Definition: polys.h:182
pDivideM
#define pDivideM(a, b)
Definition: polys.h:268
MwalkInitialForm
ideal MwalkInitialForm(ideal G, intvec *ivw)
Definition: walk.cc:749
posInT13
int posInT13(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5467
n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
IDRING
#define IDRING(a)
Definition: ipid.h:121
n_Print
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:581
Off
void Off(int sw)
switches
Definition: canonicalform.cc:1905
MPertVectors
intvec * MPertVectors(ideal G, intvec *ivtarget, int pdeg)
Definition: walk.cc:1061
plain_spoly
poly plain_spoly(poly f, poly g)
Definition: ringgb.cc:168
convSingPFactoryP
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:86
mp_InitI
matrix mp_InitI(int r, int c, int v, const ring R)
make it a v * unit matrix
Definition: matpol.cc:127
nc_rat_CreateSpoly
poly nc_rat_CreateSpoly(poly pp1, poly pp2, int ishift, const ring r)
Definition: ratgring.cc:340
slists
Definition: lists.h:21
feOptSpec
struct fe_option feOptSpec[]
gms.h
INTVEC_CMD
Definition: tok.h:100
ringRedNF
poly ringRedNF(poly f, ideal G, ring r)
Definition: ringgb.cc:117
MAltwalk1
ideal MAltwalk1(ideal Go, int op_deg, int tp_deg, intvec *curr_weight, intvec *target_weight)
Definition: walk.cc:9599
MivMatrixOrderlp
intvec * MivMatrixOrderlp(int nV)
Definition: walk.cc:1372
INTMAT_CMD
Definition: grammar.cc:279
dynl_open
void * dynl_open(char *filename)
Definition: mod_raw.cc:151
IMATELEM
#define IMATELEM(M, I, J)
Definition: intvec.h:83
coeffs_BIGINT
coeffs coeffs_BIGINT
Definition: ipid.cc:51
ring.h
idrec
Definition: idrec.h:33
feResource
static char * feResource(feResourceConfig config, int warn)
Definition: feResource.cc:254
Mivlp
intvec * Mivlp(int nR)
Definition: walk.cc:997
rEnvelope
ring rEnvelope(ring R)
Definition: ring.cc:5505
p_Add_q
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877
jjEXTENDED_SYSTEM
static BOOLEAN jjEXTENDED_SYSTEM(leftv res, leftv h)
Definition: extra.cc:2340
kstd1.h
newstruct_set_proc
BOOLEAN newstruct_set_proc(const char *bbname, const char *func, int args, procinfov pr)
Definition: newstruct.cc:859
complexNearZero
bool complexNearZero(gmp_complex *c, int digits)
Definition: mpr_complex.cc:765
system
void system(sys)
MkInterRedNextWeight
intvec * MkInterRedNextWeight(intvec *iva, intvec *ivb, ideal G)
Definition: walk.cc:2530
HCord
int HCord
Definition: kutil.cc:234
ncInitSpecialPowersMultiplication
bool ncInitSpecialPowersMultiplication(ring r)
Definition: ncSAFormula.cc:48
nc.h
probIrredTest
int probIrredTest(const CanonicalForm &F, double error)
given some error probIrredTest detects irreducibility or reducibility of F with confidence level 1-er...
Definition: facIrredTest.cc:63
pcvDim
int pcvDim(int d0, int d1)
Definition: pcv.cc:360
StringSetS
void StringSetS(const char *st)
Definition: reporter.cc:127
spectrumProc
BOOLEAN spectrumProc(leftv result, leftv first)
Definition: ipshell.cc:4070
pPrintDivisbleByStat
void pPrintDivisbleByStat()
Definition: pDebug.cc:406
Approx_Step
ideal Approx_Step(ideal L)
Ann: ???
Definition: nc.cc:250
SW_USE_EZGCD_P
static const int SW_USE_EZGCD_P
set to 1 to use EZGCD over F_q
Definition: cf_defs.h:34
mpr_base.h
bound
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
p_Shrink
poly p_Shrink(poly p, int lV, const ring r)
Definition: shiftgb.cc:369
computeMinimalPolynomial
unsigned long * computeMinimalPolynomial(unsigned long **matrix, unsigned n, unsigned long p)
Definition: minpoly.cc:428
Print
#define Print
Definition: emacs.cc:79
id_Vec2Ideal
ideal id_Vec2Ideal(poly vec, const ring R)
Definition: simpleideals.cc:1134
omMarkAsStaticAddr
void omMarkAsStaticAddr(void *addr)
pcvP2CV
poly pcvP2CV(poly p, int d0, int d1)
Definition: pcv.cc:245
om_Opts
omOpts_t om_Opts
Definition: omOpts.c:10
rSetSyzComp
void rSetSyzComp(int k, const ring r)
Definition: ring.cc:4972
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
idXXX
ideal idXXX(ideal h1, int k)
Definition: ideals.cc:878
pLastVblock
#define pLastVblock(p, lV)
Definition: shiftgb.h:29
scaLastAltVar
static short scaLastAltVar(ring r)
Definition: sca.h:25
pIsPurePower
#define pIsPurePower(p)
Definition: polys.h:225
jjSYSTEM
BOOLEAN jjSYSTEM(leftv res, leftv args)
Definition: extra.cc:228
FE_OPT_UNDEF
Definition: feOptGen.h:14
assumeStdFlag
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1470
tok.h
kstdfac.h
dynl_sym
void * dynl_sym(void *handle, const char *symbol)
Definition: mod_raw.cc:165
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
ringorder_s
s?
Definition: ring.h:82
sleftv::Typ
int Typ()
Definition: subexpr.cc:991
m
int m
Definition: cfEzgcd.cc:121
singntl_LLL
matrix singntl_LLL(matrix m, const ring s)
Definition: clapsing.cc:1796
MATCOLS
#define MATCOLS(i)
Definition: matpol.h:27
TEST_FOR
#define TEST_FOR(A)
WarnS
#define WarnS
Definition: emacs.cc:77
sleftv::rtyp
int rtyp
Definition: subexpr.h:90
syz.h
assume
#define assume(x)
Definition: mod2.h:384
distrib.h
sirandom.h
NULL
#define NULL
Definition: omList.c:9
lists
slists * lists
Definition: mpr_numeric.h:145
posInT1
int posInT1(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5167
siSeed
int siSeed
Definition: sirandom.c:29
sdb.h
MPertNextWeight
intvec * MPertNextWeight(intvec *iva, ideal G, int deg)
simpleipc_cmd
int simpleipc_cmd(char *cmd, int id, int v)
Definition: semaphore.c:167
BIMATELEM
#define BIMATELEM(M, I, J)
Definition: bigintmat.h:133
MAXPATHLEN
#define MAXPATHLEN
Definition: omRet2Info.c:21
fe_option::value
void * value
Definition: fegetopt.h:93
pcvLAddL
lists pcvLAddL(lists l1, lists l2)
Definition: pcv.cc:30
evEigenvals
lists evEigenvals(matrix M)
Definition: eigenval_ip.cc:118
ideals.h
l
int l
Definition: cfEzgcd.cc:93
Mrwalk
ideal Mrwalk(ideal Go, intvec *orig_M, intvec *target_M, int weight_rad, int pert_deg, int reduction, int printout)
Definition: walk.cc:5540
feNotImplemented
const char feNotImplemented[]
Definition: reporter.cc:53
n_Int
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ....
Definition: coeffs.h:547
R
#define R
Definition: sirandom.c:26
intvec::rows
int rows() const
Definition: intvec.h:94
evHessenberg
matrix evHessenberg(matrix M)
Definition: eigenval.cc:100
p_Setm
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:224
Warn
#define Warn
Definition: emacs.cc:76
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
nc_PrintMat
matrix nc_PrintMat(int a, int b, ring r, int metric)
returns matrix with the info on noncomm multiplication
Definition: old.gring.cc:2393
AEQ.h
slists::Init
INLINE_THIS void Init(int l=0)
feResource.h
p
int p
Definition: cfModGcd.cc:4019
setFlag
#define setFlag(A, F)
Definition: ipid.h:107
MivWeightOrderlp
intvec * MivWeightOrderlp(intvec *ivstart)
Definition: walk.cc:1405
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
iiCheckTypes
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6502
Mfpertvector
intvec * Mfpertvector(ideal G, intvec *ivtarget)
Definition: walk.cc:1479
POLY_CMD
Definition: grammar.cc:288
feOptValue
static void * feOptValue(feOptIndex opt)
Definition: feOpt.h:39
pCopy
#define pCopy(p)
return a copy of the poly
Definition: polys.h:165
ringNF
poly ringNF(poly f, ideal G, ring r)
Definition: ringgb.cc:199
ipshell.h
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:24
SW_USE_QGCD
static const int SW_USE_QGCD
set to 1 to use Encarnacion GCD over Q(a)
Definition: cf_defs.h:40
posInT15
int posInT15(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5535
minpoly.h
p_ISet
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1286
posInT0
int posInT0(const TSet, const int length, LObject &)
Definition: kutil.cc:5156
FLAG_STD
#define FLAG_STD
Definition: ipid.h:103
pHead
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:65
fglmLinearCombination
poly fglmLinearCombination(ideal source, poly monset)
Definition: fglmcomb.cc:416
Mfrwalk
ideal Mfrwalk(ideal G, intvec *ivstart, intvec *ivtarget, int weight_rad, int reduction, int printout)
Definition: walk.cc:8143
fd
int status int fd
Definition: si_signals.h:58
flintconv.h
PrintLn
void PrintLn()
Definition: reporter.cc:309
rIsSCA
static bool rIsSCA(const ring r)
Definition: nc.h:198
rField_is_long_C
static BOOLEAN rField_is_long_C(const ring r)
Definition: ring.h:536
MATROWS
#define MATROWS(i)
Definition: matpol.h:26
G
static TreeM * G
Definition: janet.cc:32
p_LPshift
poly p_LPshift(poly p, int sh, int uptodeg, int lV, const ring r)
Definition: shiftgb.cc:73
spectrum.h
getBlackboxStuff
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:16
omUpdateInfo
void omUpdateInfo()
Definition: omStats.c:23
fglm.h
ratgring.h
n_SwitchChinRem
int n_SwitchChinRem
Definition: longrat.cc:2931
LINK_CMD
Definition: tok.h:116
CMATRIX_CMD
Definition: tok.h:45
degree
int degree(const CanonicalForm &f)
Definition: canonicalform.h:309
ipid.h
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
newstructShow
void newstructShow(newstruct_desc d)
Definition: newstruct.cc:839
singclap_absFactorize
ideal singclap_absFactorize(poly f, ideal &mipos, intvec **exps, int &numFactors, const ring r)
Definition: clapsing.cc:1852
On
void On(int sw)
switches
Definition: canonicalform.cc:1898
posInT11
int posInT11(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5225
pcv.h
unifastmult
poly unifastmult(poly f, poly g, ring r)
Definition: fast_mult.cc:272
rSubring
ring rSubring(ring org_ring, sleftv *rv)
Definition: ipshell.cc:5913
sleftv::next
leftv next
Definition: subexpr.h:85
slicehilb
void slicehilb(ideal I)
Definition: hilb.cc:1131
sdb_flags
int sdb_flags
Definition: sdb.cc:31
si_opt_2
unsigned si_opt_2
Definition: options.c:6
gmp_complex
gmp_complex numbers based on
Definition: mpr_complex.h:177
BB_LIKE_LIST
#define BB_LIKE_LIST(B)
Definition: blackbox.h:54
linearAlgebra.h
coeffs.h
nc.h
singclap_neworder
char * singclap_neworder(ideal I, const ring r)
Definition: clapsing.cc:1546
feOptString
Definition: fegetopt.h:77
id_TensorModuleMult
ideal id_TensorModuleMult(const int m, const ideal M, const ring rRing)
Definition: simpleideals.cc:1683
rComplete
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3350
ncSAMult.h