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