Context Navigation

source: git/Singular/extra.cc @ b40eaa0

spielwiese

Last change on this file since b40eaa0 was d7ad81, checked in by Hans Schoenemann <hannes@…>, 12 years ago
add: system("install",...) from master
Property mode set to `100644`
File size: 109.3 KB

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

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

Download in other formats: