Context Navigation

source: git/Singular/extra.cc @ 584b82

spielwiese

Last change on this file since 584b82 was 9a4aed, checked in by Hans Schoenemann <hannes@…>, 19 months ago
fix: debug stuff p_LmDivisble...
Property mode set to `100644`
File size: 119.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: