Context Navigation

source: git/Singular/extra.cc @ f5da37

spielwiese

Last change on this file since f5da37 was f5da37, checked in by Motsak Oleksandr <motsak@…>, 15 years ago
*motsak: some fixes git-svn-id: file:///usr/local/Singular/svn/trunk@12061 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 89.0 KB

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

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

Download in other formats: