Context Navigation

iparith.cc @ 6676a2

spielwiese

Last change on this file since 6676a2 was 6676a2, checked in by Hans Schönemann <hannes@…>, 17 years ago
*hannes: gcd for bigint git-svn-id: file:///usr/local/Singular/svn/trunk@9417 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 222.0 KB

Line
1	/****************************************
2	* Computer Algebra System SINGULAR *
3	****************************************/
4	/* $Id: iparith.cc,v 1.409 2006-09-21 16:00:10 Singular Exp $ */
5
6	/*
7	* ABSTRACT: table driven kernel interface, used by interpreter
8	*/
9
10	#include <stdlib.h>
11	#include <string.h>
12	#include <ctype.h>
13	#include <stdio.h>
14	#include <time.h>
15	#include <unistd.h>
16
17	#include "mod2.h"
18	#include "tok.h"
19	#include "ipid.h"
20	#include "intvec.h"
21	#include "omalloc.h"
22	#include "polys.h"
23	#include "febase.h"
24	#include "sdb.h"
25	#include "longalg.h"
26	#include "ideals.h"
27	#include "matpol.h"
28	#include "kstd1.h"
29	#include "timer.h"
30	#include "ring.h"
31	#include "subexpr.h"
32	#include "lists.h"
33	#include "longalg.h"
34	#include "numbers.h"
35	#include "stairc.h"
36	#include "maps.h"
37	#include "maps_ip.h"
38	#include "syz.h"
39	#include "weight.h"
40	#include "ipconv.h"
41	#include "ipprint.h"
42	#include "sing_dld.h"
43	#include "attrib.h"
44	#include "silink.h"
45	#include "sparsmat.h"
46	#include "units.h"
47	#include "janet.h"
48	#include "GMPrat.h"
49	#include "tgb.h"
50	#include "walkProc.h"
51	#include "mod_raw.h"
52	#ifdef HAVE_FACTORY
53	#include "clapsing.h"
54	#include "kstdfac.h"
55	#endif
56	#ifdef HAVE_FGLM
57	#include "fglm.h"
58	#endif
59	#define HAVE_INTERPOLATION
60	#ifdef HAVE_INTERPOLATION
61	#include "interpolation.h"
62	#endif
63
64
65	#include "ipshell.h"
66
67	#include "mpr_inout.h"
68
69	#ifdef HAVE_PLURAL
70	#include "gring.h"
71	#define ALLOW_PLURAL ,1
72	#define ALLOW_PLURAL_N 1
73	#define NO_PLURAL ,0
74	#define NO_PLURAL_N 0
75	#define COMM_PLURAL ,2
76	#define COMM_PLURAL_N 2
77	#else
78	#define ALLOW_PLURAL
79	#define NO_PLURAL
80	#define COMM_PLURAL
81	#endif
82
83	/=============== types =====================/
84	struct sValCmdTab
85	{
86	short cmd;
87	short start;
88	};
89
90	typedef sValCmdTab jjValCmdTab[];
91
92	/* ifdef GENTABLE: definitions are in ipshell.h */
93	#ifndef GENTABLE
94	typedef char * (Proc1)(char );
95	struct sValCmd1
96	{
97	proc1 p;
98	short cmd;
99	short res;
100	short arg;
101	#ifdef HAVE_PLURAL
102	short valid_for_plural;
103	#endif
104	};
105
106	typedef BOOLEAN (*proc2)(leftv,leftv,leftv);
107	struct sValCmd2
108	{
109	proc2 p;
110	short cmd;
111	short res;
112	short arg1;
113	short arg2;
114	#ifdef HAVE_PLURAL
115	short valid_for_plural;
116	#endif
117	};
118
119	typedef BOOLEAN (*proc3)(leftv,leftv,leftv,leftv);
120	struct sValCmd3
121	{
122	proc3 p;
123	short cmd;
124	short res;
125	short arg1;
126	short arg2;
127	short arg3;
128	#ifdef HAVE_PLURAL
129	short valid_for_plural;
130	#endif
131	};
132	struct sValCmdM
133	{
134	proc1 p;
135	short cmd;
136	short res;
137	short number_of_args; /* -1: any, -2: any >0, .. */
138	#ifdef HAVE_PLURAL
139	short valid_for_plural;
140	#endif
141	};
142	#endif
143
144	/============= proc =======================/
145	static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport = FALSE);
146	static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op);
147	#ifdef MDEBUG
148	#define jjMakeSub(A) jjDBMakeSub(A,__FILE__,__LINE__)
149	static Subexpr jjDBMakeSub(leftv e,char *f, int l);
150	#else
151	static Subexpr jjMakeSub(leftv e);
152	#endif
153
154	/============= vars ======================/
155	extern int cmdtok;
156	extern BOOLEAN expected_parms;
157
158	#define ii_div_by_0 "div. by 0"
159	#define ii_not_for_plural "not implemented for non-commutative rings"
160
161	int iiOp; /* the current operation*/
162
163	#ifdef GENTABLE
164	cmdnames cmds[] =
165	{ // name-string alias tokval toktype
166	{ "$INVALID$", 0, -1, 0},
167	{ "and", 0, '&' , LOGIC_OP},
168	{ "attrib", 0, ATTRIB_CMD , CMD_123},
169	{ "bareiss", 0, BAREISS_CMD , CMD_123},
170	{ "betti", 0, BETTI_CMD , CMD_12},
171	{ "bigint", 0, BIGINT_CMD , ROOT_DECL},
172	#ifdef HAVE_PLURAL
173	{ "bracket", 0, BRACKET_CMD , CMD_2},
174	#endif
175	{ "break", 0, BREAK_CMD , BREAK_CMD},
176	{ "breakpoint", 0, BREAKPOINT_CMD , CMD_M},
177	{ "char", 0, CHARACTERISTIC_CMD ,CMD_1},
178	{ "char_series", 0, CHAR_SERIES_CMD , CMD_1},
179	{ "charstr", 0, CHARSTR_CMD , CMD_1},
180	{ "cleardenom", 0, CONTENT_CMD , CMD_1},
181	{ "close", 0, CLOSE_CMD , CMD_1},
182	{ "coef", 0, COEF_CMD , CMD_M},
183	{ "coeffs", 0, COEFFS_CMD , CMD_23},
184	{ "continue", 0, CONTINUE_CMD , CONTINUE_CMD},
185	{ "contract", 0, CONTRACT_CMD , CMD_2},
186	{ "convhull", 0, NEWTONPOLY_CMD, CMD_1},
187	{ "dbprint", 0, DBPRINT_CMD , CMD_M},
188	{ "def", 0, DEF_CMD , ROOT_DECL},
189	{ "defined", 0, DEFINED_CMD , CMD_1},
190	{ "deg", 0, DEG_CMD , CMD_12},
191	{ "degree", 0, DEGREE_CMD , CMD_1},
192	{ "delete", 0, DELETE_CMD , CMD_2},
193	{ "det", 0, DET_CMD , CMD_1},
194	{ "diff", 0, DIFF_CMD , CMD_2},
195	{ "dim", 0, DIM_CMD , CMD_1},
196	{ "div", 0, INTDIV_CMD , MULDIV_OP},
197	{ "division", 0, DIVISION_CMD , CMD_M},
198	{ "dump", 0, DUMP_CMD, CMD_1},
199	{ "extgcd", 0, EXTGCD_CMD , CMD_2},
200	{ "EXTGCD", 2, EXTGCD_CMD , CMD_2},
201	{ "ERROR", 0, ERROR_CMD , CMD_1},
202	{ "eliminate", 0, ELIMINATION_CMD, CMD_23},
203	{ "else", 0, ELSE_CMD , ELSE_CMD},
204	#ifdef HAVE_PLURAL
205	{ "envelope", 0, ENVELOPE_CMD , CMD_1},
206	#endif
207	{ "eval", 0, EVAL , EVAL},
208	{ "example", 0, EXAMPLE_CMD , EXAMPLE_CMD},
209	{ "execute", 0, EXECUTE_CMD , CMD_1},
210	{ "export", 0, EXPORT_CMD , EXPORT_CMD},
211	{ "exportto", 0, EXPORTTO_CMD , CMD_2},
212	{ "factorize", 0, FAC_CMD , CMD_12},
213	{ "fetch", 0, FETCH_CMD , CMD_2},
214	{ "fglm", 0, FGLM_CMD , CMD_2},
215	{ "fglmquot", 0, FGLMQUOT_CMD, CMD_2},
216	{ "find", 0, FIND_CMD , CMD_23},
217	{ "finduni", 0, FINDUNI_CMD, CMD_1},
218	{ "forif", 0, IF_CMD , IF_CMD},
219	{ "freemodule", 0, FREEMODULE_CMD , CMD_1},
220	{ "facstd", 0, FACSTD_CMD , CMD_12},
221	{ "frwalk", 0, FWALK_CMD , CMD_23},
222	{ "gen", 0, E_CMD , CMD_1},
223	{ "getdump", 0, GETDUMP_CMD, CMD_1},
224	{ "gcd", 0, GCD_CMD , CMD_2},
225	{ "GCD", 2, GCD_CMD , CMD_2},
226	{ "hilb", 0, HILBERT_CMD , CMD_123},
227	{ "highcorner", 0, HIGHCORNER_CMD, CMD_1},
228	{ "homog", 0, HOMOG_CMD , CMD_12},
229	{ "hres", 0, HRES_CMD , CMD_2},
230	{ "ideal", 0, IDEAL_CMD , IDEAL_CMD},
231	{ "if", 0, IF_CMD , IF_CMD},
232	{ "imap", 0, IMAP_CMD , CMD_2},
233	{ "impart", 0, IMPART_CMD , CMD_1},
234	{ "importfrom", 0, IMPORTFROM_CMD , CMD_2},
235	{ "indepSet", 0, INDEPSET_CMD , CMD_12},
236	{ "insert", 0, INSERT_CMD , CMD_23},
237	{ "int", 0, INT_CMD , ROOT_DECL},
238	#ifdef HAVE_INTERPOLATION
239	{ "interpolation",0,INTERPOLATE_CMD , CMD_2},
240	#endif
241	{ "interred", 0, INTERRED_CMD , CMD_1},
242	{ "intersect", 0, INTERSECT_CMD , CMD_M},
243	{ "intmat", 0, INTMAT_CMD , INTMAT_CMD},
244	{ "intvec", 0, INTVEC_CMD , ROOT_DECL_LIST},
245	{ "jacob", 0, JACOB_CMD , CMD_1},
246	{ "janet", 0, JANET_CMD , CMD_12},
247	{ "jet", 0, JET_CMD , CMD_M},
248	{ "kbase", 0, KBASE_CMD , CMD_12},
249	{ "keepring", 0, KEEPRING_CMD , KEEPRING_CMD},
250	{ "kill", 0, KILL_CMD , KILL_CMD},
251	{ "killattrib", 0, KILLATTR_CMD , CMD_12},
252	{ "koszul", 0, KOSZUL_CMD , CMD_23},
253	{ "kres", 0, KRES_CMD , CMD_2},
254	{ "laguerre", 0, LAGSOLVE_CMD, CMD_3},
255	{ "lead", 0, LEAD_CMD , CMD_1},
256	{ "leadcoef", 0, LEADCOEF_CMD , CMD_1},
257	{ "leadexp", 0, LEADEXP_CMD , CMD_1},
258	{ "leadmonom", 0, LEADMONOM_CMD , CMD_1},
259	{ "LIB", 0, LIB_CMD , SYSVAR},
260	{ "lift", 0, LIFT_CMD , CMD_23},
261	{ "liftstd", 0, LIFTSTD_CMD , CMD_2},
262	{ "link", 0, LINK_CMD , ROOT_DECL},
263	{ "listvar", 0, LISTVAR_CMD , LISTVAR_CMD},
264	{ "list", 0, LIST_CMD , ROOT_DECL_LIST},
265	{ "load", 0, LOAD_CMD , CMD_12},
266	{ "lres", 0, LRES_CMD , CMD_2},
267	{ "map", 0, MAP_CMD , RING_DECL},
268	{ "matrix", 0, MATRIX_CMD , MATRIX_CMD},
269	{ "maxideal", 0, MAXID_CMD , CMD_1},
270	{ "memory", 0, MEMORY_CMD , CMD_1},
271	{ "minbase", 0, MINBASE_CMD , CMD_1},
272	{ "minor", 0, MINOR_CMD , CMD_23},
273	{ "minres", 0, MINRES_CMD , CMD_1},
274	{ "mod", 0, INTMOD_CMD , MULDIV_OP},
275	{ "module", 0, MODUL_CMD , MODUL_CMD},
276	{ "modulo", 0, MODULO_CMD , CMD_2},
277	{ "monitor", 0, MONITOR_CMD , CMD_12},
278	{ "mpresmat", 0, MPRES_CMD, CMD_2},
279	{ "mult", 0, MULTIPLICITY_CMD , CMD_1},
280	#ifdef OLD_RES
281	{ "mres", 0, MRES_CMD , CMD_23},
282	#else
283	{ "mres", 0, MRES_CMD , CMD_2},
284	#endif
285	{ "mstd", 0, MSTD_CMD , CMD_1},
286	{ "nameof", 0, NAMEOF_CMD , CMD_1},
287	{ "names", 0, NAMES_CMD , CMD_M},
288	#ifdef HAVE_PLURAL
289	{ "ncalgebra", 0, NCALGEBRA_CMD , CMD_2},
290	#endif
291	{ "ncols", 0, COLS_CMD , CMD_1},
292	{ "not", 0, NOT , NOT},
293	{ "npars", 0, NPARS_CMD , CMD_1},
294	#ifdef OLD_RES
295	{ "nres", 0, RES_CMD , CMD_23},
296	#else
297	{ "nres", 0, RES_CMD , CMD_2},
298	#endif
299	{ "nrows", 0, ROWS_CMD , CMD_1},
300	{ "number", 0, NUMBER_CMD , RING_DECL},
301	{ "nvars", 0, NVARS_CMD , CMD_1},
302	{ "open", 0, OPEN_CMD , CMD_1},
303	#ifdef HAVE_PLURAL
304	{ "oppose", 0, OPPOSE_CMD , CMD_2},
305	{ "opposite", 0, OPPOSITE_CMD , CMD_1},
306	#endif
307	{ "option", 0, OPTION_CMD , CMD_M},
308	{ "or", 0, '\|' , LOGIC_OP},
309	{ "ord", 0, ORD_CMD , CMD_1},
310	{ "ordstr", 0, ORDSTR_CMD , CMD_1},
311	{ "package", 0, PACKAGE_CMD , ROOT_DECL},
312	{ "par", 0, PAR_CMD , CMD_1},
313	{ "parameter", 0, PARAMETER , PARAMETER},
314	{ "pardeg", 0, PARDEG_CMD , CMD_1},
315	{ "parstr", 0, PARSTR_CMD , CMD_12},
316	{ "poly", 0, POLY_CMD , RING_DECL},
317	{ "preimage", 0, PREIMAGE_CMD , CMD_13},
318	{ "prime", 0, PRIME_CMD , CMD_1},
319	{ "print", 0, PRINT_CMD , CMD_12},
320	{ "prune", 0, PRUNE_CMD , CMD_1},
321	{ "proc", 0, PROC_CMD , PROC_CMD},
322	{ "qhweight", 0, QHWEIGHT_CMD , CMD_1},
323	{ "qring", 0, QRING_CMD , ROOT_DECL},
324	{ "quote", 0, QUOTE , QUOTE},
325	{ "quotient", 0, QUOTIENT_CMD , CMD_2},
326	{ "random", 0, RANDOM_CMD , CMD_23},
327	{ "read", 0, READ_CMD , CMD_12},
328	{ "reduce", 0, REDUCE_CMD , CMD_M},
329	{ "regularity", 0, REGULARITY_CMD , CMD_1},
330	{ "repart", 0, REPART_CMD , CMD_1},
331	{ "reservedName",0, RESERVEDNAME_CMD , CMD_M},
332	{ "resolution", 0, RESOLUTION_CMD , RING_DECL},
333	{ "resultant", 0, RESULTANT_CMD, CMD_3},
334	{ "return", 0, RETURN , RETURN},
335	{ "RETURN", 0, END_GRAMMAR , RETURN},
336	{ "ring", 0, RING_CMD , RING_CMD},
337	{ "ringlist", 0, RINGLIST_CMD , CMD_1},
338	{ "rvar", 0, IS_RINGVAR , CMD_1},
339	{ "setring", 0, SETRING_CMD , SETRING_CMD},
340	{ "simplex", 0, SIMPLEX_CMD, CMD_M},
341	{ "simplify", 0, SIMPLIFY_CMD , CMD_2},
342	{ "size", 0, COUNT_CMD , CMD_1},
343	{ "slimgb", 0, SLIM_GB_CMD , CMD_1},
344	{ "sortvec", 0, SORTVEC_CMD , CMD_1},
345	#ifdef OLD_RES
346	{ "sres", 0, SRES_CMD , CMD_23},
347	#else
348	{ "sres", 0, SRES_CMD , CMD_2},
349	#endif
350	{ "status", 0, STATUS_CMD, CMD_M},
351	{ "std", 0, STD_CMD , CMD_123},
352	{ "string", 0, STRING_CMD , ROOT_DECL_LIST},
353	{ "subst", 0, SUBST_CMD , CMD_M},
354	{ "system", 0, SYSTEM_CMD, CMD_M},
355	{ "syz", 0, SYZYGY_CMD , CMD_1},
356	{ "test", 0, TEST_CMD , CMD_M},
357	{ "trace", 0, TRACE_CMD , CMD_1},
358	{ "transpose", 0, TRANSPOSE_CMD , CMD_1},
359	#ifdef HAVE_PLURAL
360	{ "twostd", 0, TWOSTD_CMD , CMD_1},
361	#endif
362	{ "type", 0, TYPE_CMD , TYPE_CMD},
363	{ "typeof", 0, TYPEOF_CMD , CMD_1},
364	{ "uressolve", 0, URSOLVE_CMD, CMD_M},
365	{ "vandermonde", 0, VANDER_CMD, CMD_3},
366	{ "var", 0, VAR_CMD , CMD_1},
367	{ "varstr", 0, VARSTR_CMD , CMD_12},
368	{ "vdim", 0, VDIM_CMD , CMD_1},
369	{ "vector", 0, VECTOR_CMD , RING_DECL},
370	{ "wedge", 0, WEDGE_CMD , CMD_2},
371	{ "weight", 0, WEIGHT_CMD , CMD_1},
372	{ "whileif", 0, IF_CMD , IF_CMD},
373	{ "write", 0, WRITE_CMD , CMD_M},
374	/* delete for next version:*/
375	{ "IN", 1, LEAD_CMD , CMD_1},
376	{ "NF", 1, REDUCE_CMD , CMD_M},
377	{ "multiplicity",1, MULTIPLICITY_CMD , CMD_1},
378	{ "verbose", 2, OPTION_CMD , CMD_M},
379	// { "rank", 1, ROWS_CMD , CMD_1},
380	// { "Current", 0, -1 , SYSVAR},
381	// { "Top", 0, -1 , SYSVAR},
382	// { "Up", 0, -1 , SYSVAR},
383
384	/* set sys vars*/
385	{ "degBound", 0, VMAXDEG , SYSVAR},
386	{ "echo", 0, VECHO , SYSVAR},
387	{ "minpoly", 0, VMINPOLY , SYSVAR},
388	{ "multBound", 0, VMAXMULT , SYSVAR},
389	{ "noether", 0, VNOETHER , SYSVAR},
390	{ "pagelength", 0, VPAGELENGTH , SYSVAR},
391	{ "pagewidth", 0, VCOLMAX , SYSVAR},
392	{ "printlevel", 0, VPRINTLEVEL , SYSVAR},
393	{ "short", 0, VSHORTOUT , SYSVAR},
394	{ "timer", 0, VTIMER , SYSVAR},
395	{ "rtimer", 0, VRTIMER, SYSVAR},
396	{ "TRACE", 0, TRACE , SYSVAR},
397	{ "voice", 0, VOICE , SYSVAR},
398
399	/* other reserved words:scanner.l */
400	{ "pause", 2, -1 , 0},
401	{ "while", 0, -1 , 0},
402	{ "for", 0, -1 , 0},
403	{ "help", 0, -1 , 0},
404	{ "newline", 0, -1 , 0},
405	{ "exit", 0, -1 , 0},
406	{ "quit", 0, -1 , 0},
407	/* end of list marker */
408	{ NULL, 0, 0, 0}
409	};
410	#endif
411
412	/=================== operations with 2 args.: static proc =================/
413	static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
414	{
415	intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
416	int bb = (int)(long)(v->Data());
417	if (errorreported) return TRUE;
418	switch (iiOp)
419	{
420	case '+': (*aa) += bb; break;
421	case '-': (*aa) -= bb; break;
422	case '': (aa) *= bb; break;
423	case '/':
424	case INTDIV_CMD: (*aa) /= bb; break;
425	case '%':
426	case INTMOD_CMD: (*aa) %= bb; break;
427	}
428	res->data=(char *)aa;
429	return FALSE;
430	}
431	static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
432	{
433	return jjOP_IV_I(res,v,u);
434	}
435	static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
436	{
437	intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
438	int bb = (int)(long)(v->Data());
439	int i=si_min(aa->rows(),aa->cols());
440	switch (iiOp)
441	{
442	case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
443	break;
444	case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
445	break;
446	}
447	res->data=(char *)aa;
448	return FALSE;
449	}
450	static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
451	{
452	return jjOP_IM_I(res,v,u);
453	}
454	static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
455	{
456	res->data=(char *)new intvec((int)(long)u->Data(),(int)(long)v->Data());
457	return FALSE;
458	}
459	static void jjEQUAL_REST(leftv res,leftv u,leftv v);
460	static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
461	{
462	intvec* a = (intvec * )(u->Data());
463	intvec* b = (intvec * )(v->Data());
464	int r=a->compare(b);
465	switch (iiOp)
466	{
467	case '<':
468	res->data = (char *) (r<0);
469	break;
470	case '>':
471	res->data = (char *) (r>0);
472	break;
473	case LE:
474	res->data = (char *) (r<=0);
475	break;
476	case GE:
477	res->data = (char *) (r>=0);
478	break;
479	case EQUAL_EQUAL:
480	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
481	res->data = (char *) (r==0);
482	break;
483	}
484	jjEQUAL_REST(res,u,v);
485	return r==-2;
486	}
487	static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
488	{
489	intvec* a = (intvec * )(u->Data());
490	int b = (int)(long)(v->Data());
491	int r=a->compare(b);
492	switch (iiOp)
493	{
494	case '<':
495	res->data = (char *) (r<0);
496	break;
497	case '>':
498	res->data = (char *) (r>0);
499	break;
500	case LE:
501	res->data = (char *) (r<=0);
502	break;
503	case GE:
504	res->data = (char *) (r>=0);
505	break;
506	case EQUAL_EQUAL:
507	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
508	res->data = (char *) (r==0);
509	break;
510	}
511	jjEQUAL_REST(res,u,v);
512	return FALSE;
513	}
514	static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
515	{
516	poly p=(poly)u->Data();
517	poly q=(poly)v->Data();
518	int r=pCmp(p,q);
519	if (r==0)
520	{
521	/* compare lead coeffs */
522	number h=nSub(pGetCoeff(p),pGetCoeff(q));
523	r = -1+nIsZero(h)+2nGreaterZero(h); / -1: <, 0:==, 1: > */
524	nDelete(&h);
525	}
526	else if (p==NULL)
527	{
528	if (q==NULL)
529	{
530	/* compare 0, 0 */
531	r=0;
532	}
533	else if(pIsConstant(q))
534	{
535	/* compare 0, const */
536	r = 1-2nGreaterZero(pGetCoeff(q)); / -1: <, 1: > */
537	}
538	}
539	else if (q==NULL)
540	{
541	if (pIsConstant(p))
542	{
543	/* compare const, 0 */
544	r = -1+2nGreaterZero(pGetCoeff(p)); / -1: <, 1: > */
545	}
546	}
547	switch (iiOp)
548	{
549	case '<':
550	res->data = (char *) (r < 0);
551	break;
552	case '>':
553	res->data = (char *) (r > 0);
554	break;
555	case LE:
556	res->data = (char *) (r <= 0);
557	break;
558	case GE:
559	res->data = (char *) (r >= 0);
560	break;
561	//case EQUAL_EQUAL:
562	//case NOTEQUAL: /* negation handled by jjEQUAL_REST */
563	// res->data = (char *) (r == 0);
564	// break;
565	}
566	jjEQUAL_REST(res,u,v);
567	return FALSE;
568	}
569	static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
570	{
571	char* a = (char * )(u->Data());
572	char* b = (char * )(v->Data());
573	int result = strcmp(a,b);
574	switch (iiOp)
575	{
576	case '<':
577	res->data = (char *) (result < 0);
578	break;
579	case '>':
580	res->data = (char *) (result > 0);
581	break;
582	case LE:
583	res->data = (char *) (result <= 0);
584	break;
585	case GE:
586	res->data = (char *) (result >= 0);
587	break;
588	case EQUAL_EQUAL:
589	case NOTEQUAL: /* negation handled by jjEQUAL_REST */
590	res->data = (char *) (result == 0);
591	break;
592	}
593	jjEQUAL_REST(res,u,v);
594	return FALSE;
595	}
596	static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
597	{
598	if (u->Next()!=NULL)
599	{
600	u=u->next;
601	res->next = (leftv)omAllocBin(sleftv_bin);
602	return iiExprArith2(res->next,u,iiOp,v);
603	}
604	else if (v->Next()!=NULL)
605	{
606	v=v->next;
607	res->next = (leftv)omAllocBin(sleftv_bin);
608	return iiExprArith2(res->next,u,iiOp,v);
609	}
610	return FALSE;
611	}
612	static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
613	{
614	int b=(int)(long)u->Data();
615	int e=(int)(long)v->Data();
616	int rc = 1;
617	BOOLEAN overflow=FALSE;
618	if (e >= 0)
619	{
620	if (b==0)
621	{
622	rc=0;
623	}
624	else
625	{
626	int oldrc;
627	while ((e--)!=0)
628	{
629	oldrc=rc;
630	rc *= b;
631	if (!overflow)
632	{
633	if(rc/b!=oldrc) overflow=TRUE;
634	}
635	}
636	if (overflow)
637	WarnS("int overflow(^), result may be wrong");
638	}
639	res->data = (char *)rc;
640	if (u!=NULL) return jjOP_REST(res,u,v);
641	return FALSE;
642	}
643	else
644	{
645	WerrorS("exponent must be non-negative");
646	return TRUE;
647	}
648	}
649	static BOOLEAN jjPOWER_BI(leftv res, leftv u, leftv v)
650	{
651	int e=(int)(long)v->Data();
652	number n=(number)u->Data();
653	if (e>=0)
654	{
655	nlPower(n,e,(number*)&res->data);
656	}
657	else
658	{
659	WerrorS("exponent must be non-negative");
660	return TRUE;
661	}
662	if (u!=NULL) return jjOP_REST(res,u,v);
663	return FALSE;
664	}
665	static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
666	{
667	int e=(int)(long)v->Data();
668	number n=(number)u->Data();
669	int d=0;
670	if (e<0)
671	{
672	n=nInvers(n);
673	e=-e;
674	d=1;
675	}
676	nPower(n,e,(number*)&res->data);
677	if (d) nDelete(&n);
678	if (u!=NULL) return jjOP_REST(res,u,v);
679	return FALSE;
680	}
681	static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
682	{
683	res->data = (char *)pPower((poly)u->CopyD(POLY_CMD),(int)(long)v->Data());
684	if (u!=NULL) return jjOP_REST(res,u,v);
685	return FALSE;
686	}
687	static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
688	{
689	res->data = (char *)idPower((ideal)(u->Data()),(int)(long)(v->Data()));
690	if (u!=NULL) return jjOP_REST(res,u,v);
691	return FALSE;
692	}
693	static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
694	{
695	u=u->next;
696	v=v->next;
697	if (u==NULL)
698	{
699	if (v==NULL) return FALSE; /* u==NULL, v==NULL */
700	if (iiOp=='-') /* u==NULL, v<>NULL, iiOp=='-'*/
701	{
702	do
703	{
704	if (res->next==NULL)
705	res->next = (leftv)omAlloc0Bin(sleftv_bin);
706	leftv tmp_v=v->next;
707	v->next=NULL;
708	BOOLEAN b=iiExprArith1(res->next,v,'-');
709	v->next=tmp_v;
710	if (b)
711	return TRUE;
712	v=tmp_v;
713	res=res->next;
714	} while (v!=NULL);
715	return FALSE;
716	}
717	loop /* u==NULL, v<>NULL, iiOp=='+' */
718	{
719	res->next = (leftv)omAlloc0Bin(sleftv_bin);
720	res=res->next;
721	res->data = v->CopyD();
722	res->rtyp = v->Typ();
723	v=v->next;
724	if (v==NULL) return FALSE;
725	}
726	}
727	if (v!=NULL) /* u<>NULL, v<>NULL */
728	{
729	do
730	{
731	res->next = (leftv)omAlloc0Bin(sleftv_bin);
732	leftv tmp_u=u->next; u->next=NULL;
733	leftv tmp_v=v->next; v->next=NULL;
734	BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
735	u->next=tmp_u;
736	v->next=tmp_v;
737	if (b)
738	return TRUE;
739	u=tmp_u;
740	v=tmp_v;
741	res=res->next;
742	} while ((u!=NULL) && (v!=NULL));
743	return FALSE;
744	}
745	loop /* u<>NULL, v==NULL */
746	{
747	res->next = (leftv)omAlloc0Bin(sleftv_bin);
748	res=res->next;
749	res->data = u->CopyD();
750	res->rtyp = u->Typ();
751	u=u->next;
752	if (u==NULL) return FALSE;
753	}
754	}
755	static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
756	{
757	#ifdef HAVE_NS
758	idhdl packhdl;
759
760	switch(u->Typ())
761	{
762	case 0:
763	Print("%s of type 'ANY'. Trying load.\n", v->name);
764	if(iiTryLoadLib(u, u->name))
765	{
766	Werror("'%s' no such package", u->name);
767	return TRUE;
768	}
769	syMake(u,u->name,NULL);
770	// else: use next case !!! no break !!!
771
772	case PACKAGE_CMD:
773	packhdl = (idhdl)u->data;
774	if((!IDPACKAGE(packhdl)->loaded)
775	&& (IDPACKAGE(packhdl)->language > LANG_TOP))
776	{
777	//if(iiReLoadLib(packhdl))
778	// Werror("unable to reload package '%s'", IDID(packhdl));
779	Werror("'%s' not loaded", u->name);
780	return TRUE;
781	}
782	if(v->rtyp == IDHDL)
783	{
784	v->name = omStrDup(v->name);
785	}
786	v->req_packhdl=IDPACKAGE(packhdl);
787	v->packhdl=IDPACKAGE(packhdl);
788	syMake(v, v->name, packhdl);
789	memcpy(res, v, sizeof(sleftv));
790	memset(v, 0, sizeof(sleftv));
791	break;
792
793	case DEF_CMD:
794	break;
795
796	default:
797	WerrorS("<package>::<id> expected");
798	return TRUE;
799	}
800	#else
801	WerrorS("package is not supported in this version");
802	#endif /* HAVE_NS */
803	return FALSE;
804	}
805	static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
806	{
807	unsigned int a=(unsigned int)(unsigned long)u->Data();
808	unsigned int b=(unsigned int)(unsigned long)v->Data();
809	unsigned int c=a+b;
810	res->data = (char *)c;
811	if (((Sy_bit(31)&a)==(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
812	{
813	WarnS("int overflow(+), result may be wrong");
814	}
815	return jjPLUSMINUS_Gen(res,u,v);
816	}
817	static BOOLEAN jjPLUS_BI(leftv res, leftv u, leftv v)
818	{
819	res->data = (char *)(nlAdd((number)u->Data(), (number)v->Data()));
820	return jjPLUSMINUS_Gen(res,u,v);
821	}
822	static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
823	{
824	res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
825	return jjPLUSMINUS_Gen(res,u,v);
826	}
827	static BOOLEAN jjPLUS_P(leftv res, leftv u, leftv v)
828	{
829	res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
830	return jjPLUSMINUS_Gen(res,u,v);
831	}
832	static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
833	{
834	res->data = (char )ivAdd((intvec)(u->Data()), (intvec*)(v->Data()));
835	if (res->data==NULL)
836	{
837	WerrorS("intmat size not compatible");
838	return TRUE;
839	}
840	return jjPLUSMINUS_Gen(res,u,v);
841	return FALSE;
842	}
843	static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
844	{
845	res->data = (char *)(mpAdd((matrix)u->Data() , (matrix)v->Data()));
846	if (res->data==NULL)
847	{
848	WerrorS("matrix size not compatible");
849	return TRUE;
850	}
851	return jjPLUSMINUS_Gen(res,u,v);
852	}
853	static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
854	{
855	matrix m=(matrix)u->Data();
856	matrix p= mpInitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)));
857	if (iiOp=='+')
858	res->data = (char *)mpAdd(m , p);
859	else
860	res->data = (char *)mpSub(m , p);
861	idDelete((ideal *)&p);
862	return jjPLUSMINUS_Gen(res,u,v);
863	}
864	static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
865	{
866	return jjPLUS_MA_P(res,v,u);
867	}
868	static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
869	{
870	char* a = (char * )(u->Data());
871	char* b = (char * )(v->Data());
872	char* r = (char * )omAlloc(strlen(a) + strlen(b) + 1);
873	strcpy(r,a);
874	strcat(r,b);
875	res->data=r;
876	return jjPLUSMINUS_Gen(res,u,v);
877	}
878	static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
879	{
880	res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
881	return jjPLUSMINUS_Gen(res,u,v);
882	}
883	static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
884	{
885	unsigned int a=(unsigned int)(unsigned long)u->Data();
886	unsigned int b=(unsigned int)(unsigned long)v->Data();
887	unsigned int c=a-b;
888	if (((Sy_bit(31)&a)!=(Sy_bit(31)&b))&&((Sy_bit(31)&a)!=(Sy_bit(31)&c)))
889	{
890	WarnS("int overflow(-), result may be wrong");
891	}
892	res->data = (char *)c;
893	return jjPLUSMINUS_Gen(res,u,v);
894	}
895	static BOOLEAN jjMINUS_BI(leftv res, leftv u, leftv v)
896	{
897	res->data = (char *)(nlSub((number)u->Data(), (number)v->Data()));
898	return jjPLUSMINUS_Gen(res,u,v);
899	}
900	static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
901	{
902	res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
903	return jjPLUSMINUS_Gen(res,u,v);
904	}
905	static BOOLEAN jjMINUS_P(leftv res, leftv u, leftv v)
906	{
907	res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
908	return jjPLUSMINUS_Gen(res,u,v);
909	}
910	static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
911	{
912	res->data = (char )ivSub((intvec)(u->Data()), (intvec*)(v->Data()));
913	if (res->data==NULL)
914	{
915	WerrorS("intmat size not compatible");
916	return TRUE;
917	}
918	return jjPLUSMINUS_Gen(res,u,v);
919	}
920	static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
921	{
922	res->data = (char *)(mpSub((matrix)u->Data() , (matrix)v->Data()));
923	if (res->data==NULL)
924	{
925	WerrorS("matrix size not compatible");
926	return TRUE;
927	}
928	return jjPLUSMINUS_Gen(res,u,v);
929	return FALSE;
930	}
931	static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
932	{
933	int a=(int)(long)u->Data();
934	int b=(int)(long)v->Data();
935	int c=a * b;
936	if ((b!=0) && (c/b !=a))
937	WarnS("int overflow(*), result may be wrong");
938	res->data = (char *)c;
939	if ((u->Next()!=NULL) \|\| (v->Next()!=NULL))
940	return jjOP_REST(res,u,v);
941	return FALSE;
942	}
943	static BOOLEAN jjTIMES_BI(leftv res, leftv u, leftv v)
944	{
945	res->data = (char *)(nlMult( (number)u->Data(), (number)v->Data()));
946	if ((v->next!=NULL) \|\| (u->next!=NULL))
947	return jjOP_REST(res,u,v);
948	return FALSE;
949	}
950	static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
951	{
952	res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
953	if ((v->next!=NULL) \|\| (u->next!=NULL))
954	return jjOP_REST(res,u,v);
955	return FALSE;
956	}
957	static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
958	{
959	poly a;
960	poly b;
961
962	if (v->next==NULL)
963	{
964	a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
965	if (u->next==NULL)
966	{
967	b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
968	res->data = (char *)(pMult( a, b));
969	return FALSE;
970	}
971	// u->next exists: copy v
972	b=pCopy((poly)v->Data());
973	res->data = (char *)(pMult( a, b));
974	return jjOP_REST(res,u,v);
975	}
976	// v->next exists: copy u
977	a=pCopy((poly)u->Data());
978	b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
979	res->data = (char *)(pMult( a, b));
980	return jjOP_REST(res,u,v);
981	}
982	static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
983	{
984	res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
985	if ((v->next!=NULL) \|\| (u->next!=NULL))
986	return jjOP_REST(res,u,v);
987	return FALSE;
988	}
989	static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
990	{
991	res->data = (char )ivMult((intvec)(u->Data()), (intvec*)(v->Data()));
992	if (res->data==NULL)
993	{
994	WerrorS("intmat size not compatible");
995	return TRUE;
996	}
997	if ((v->next!=NULL) \|\| (u->next!=NULL))
998	return jjOP_REST(res,u,v);
999	return FALSE;
1000	}
1001	static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
1002	{
1003	poly p=(poly)v->CopyD(POLY_CMD);
1004	int r=pMaxComp(p);/* recompute the rank for the case idealvector/
1005	ideal I= (ideal)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
1006	if (r>0) I->rank=r;
1007	res->data = (char *)I;
1008	return FALSE;
1009	}
1010	static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
1011	{
1012	return jjTIMES_MA_P1(res,v,u);
1013	}
1014	static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
1015	{
1016	number n=(number)v->CopyD(NUMBER_CMD);
1017	poly p=pOne();
1018	pSetCoeff(p,n);
1019	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),p);
1020	return FALSE;
1021	}
1022	static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
1023	{
1024	return jjTIMES_MA_N1(res,v,u);
1025	}
1026	static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
1027	{
1028	res->data = (char *)mpMultI((matrix)u->CopyD(MATRIX_CMD),(int)(long)v->Data());
1029	return FALSE;
1030	}
1031	static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
1032	{
1033	return jjTIMES_MA_I1(res,v,u);
1034	}
1035	static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
1036	{
1037	res->data = (char *)mpMult((matrix)u->Data(),(matrix)v->Data());
1038	if (res->data==NULL)
1039	{
1040	WerrorS("matrix size not compatible");
1041	return TRUE;
1042	}
1043	if ((v->next!=NULL) \|\| (u->next!=NULL))
1044	return jjOP_REST(res,u,v);
1045	return FALSE;
1046	}
1047	static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
1048	{
1049	res->data = (char *)((int)((long)u->Data()) >= (int)((long)v->Data()));
1050	return FALSE;
1051	}
1052	static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
1053	{
1054	number h=nSub((number)u->Data(),(number)v->Data());
1055	res->data = (char *) (nGreaterZero(h)\|\|(nIsZero(h)));
1056	nDelete(&h);
1057	return FALSE;
1058	}
1059	static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
1060	{
1061	res->data = (char *)((int)((long)u->Data()) > (int)((long)v->Data()));
1062	return FALSE;
1063	}
1064	static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
1065	{
1066	number h=nSub((number)u->Data(),(number)v->Data());
1067	res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1068	nDelete(&h);
1069	return FALSE;
1070	}
1071	static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
1072	{
1073	res->data = (char *)((int)((long)u->Data()) <= (int)((long)v->Data()));
1074	return FALSE;
1075	}
1076	static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
1077	{
1078	number h=nSub((number)v->Data(),(number)u->Data());
1079	res->data = (char *) (nGreaterZero(h)\|\|nIsZero(h));
1080	nDelete(&h);
1081	return FALSE;
1082	}
1083	static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
1084	{
1085	res->data = (char *)((int)((long)u->Data()) < (int)((long)v->Data()));
1086	return FALSE;
1087	}
1088	static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
1089	{
1090	number h=nSub((number)v->Data(),(number)u->Data());
1091	res->data = (char *) (nGreaterZero(h)&&(!nIsZero(h)));
1092	nDelete(&h);
1093	return FALSE;
1094	}
1095	static BOOLEAN jjDIVMOD_I(leftv res, leftv u, leftv v)
1096	{
1097	int a= (int)(long)u->Data();
1098	int b= (int)(long)v->Data();
1099	if (b==0)
1100	{
1101	WerrorS(ii_div_by_0);
1102	return TRUE;
1103	}
1104	int bb=ABS(b);
1105	int c=a%bb;
1106	if(c<0) c+=bb;
1107	int r=0;
1108	switch (iiOp)
1109	{
1110	case INTMOD_CMD:
1111	r=c; break;
1112	case '%':
1113	r= (a % b); break;
1114	case INTDIV_CMD:
1115	r=((a-c) /b); break;
1116	case '/':
1117	r= (a / b); break;
1118	}
1119	res->data=(void *)r;
1120	return FALSE;
1121	}
1122	static BOOLEAN jjDIV_BI(leftv res, leftv u, leftv v)
1123	{
1124	number q=(number)v->Data();
1125	if (nlIsZero(q))
1126	{
1127	WerrorS(ii_div_by_0);
1128	return TRUE;
1129	}
1130	q = nlIntDiv((number)u->Data(),q);
1131	nlNormalize(q);
1132	res->data = (char *)q;
1133	return FALSE;
1134	}
1135	static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
1136	{
1137	number q=(number)v->Data();
1138	if (nIsZero(q))
1139	{
1140	WerrorS(ii_div_by_0);
1141	return TRUE;
1142	}
1143	q = nDiv((number)u->Data(),q);
1144	nNormalize(q);
1145	res->data = (char *)q;
1146	return FALSE;
1147	}
1148	static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
1149	{
1150	poly q=(poly)v->Data();
1151	if (q==NULL)
1152	{
1153	WerrorS(ii_div_by_0);
1154	return TRUE;
1155	}
1156	poly p=(poly)(u->Data());
1157	if (p==NULL)
1158	{
1159	res->data=NULL;
1160	return FALSE;
1161	}
1162	if (pNext(q)!=NULL)
1163	{
1164	#ifdef HAVE_FACTORY
1165	if(pGetComp(p)==0)
1166	{
1167	res->data=(void)(singclap_pdivide(p /(poly)(u->Data())*/ ,
1168	q /(poly)(v->Data())/ ));
1169	}
1170	else
1171	{
1172	int comps=pMaxComp(p);
1173	ideal I=idInit(comps,1);
1174	p=pCopy(p);
1175	poly h;
1176	int i;
1177	// conversion to a list of polys:
1178	while (p!=NULL)
1179	{
1180	i=pGetComp(p)-1;
1181	h=pNext(p);
1182	pNext(p)=NULL;
1183	pSetComp(p,0);
1184	I->m[i]=pAdd(I->m[i],p);
1185	p=h;
1186	}
1187	// division and conversion to vector:
1188	h=NULL;
1189	p=NULL;
1190	for(i=comps-1;i>=0;i--)
1191	{
1192	if (I->m[i]!=NULL)
1193	{
1194	h=singclap_pdivide(I->m[i],q);
1195	pSetCompP(h,i+1);
1196	p=pAdd(p,h);
1197	}
1198	}
1199	idDelete(&I);
1200	res->data=(void *)p;
1201	}
1202	#else
1203	WerrorS("division only by a monomial");
1204	return TRUE;
1205	#endif
1206	}
1207	else
1208	{
1209	res->data = (char *)pDivideM(pCopy(p),pHead(q));
1210	}
1211	return FALSE;
1212	}
1213	static BOOLEAN jjDIV_Ma(leftv res, leftv u, leftv v)
1214	{
1215	poly q=(poly)v->Data();
1216	if (q==NULL)
1217	{
1218	WerrorS(ii_div_by_0);
1219	return TRUE;
1220	}
1221	matrix m=(matrix)(u->Data());
1222	int r=m->rows();
1223	int c=m->cols();
1224	matrix mm=mpNew(r,c);
1225	int i,j;
1226	for(i=r;i>0;i--)
1227	{
1228	for(j=c;j>0;j--)
1229	{
1230	if (pNext(q)!=NULL)
1231	{
1232	#ifdef HAVE_FACTORY
1233	MATELEM(mm,i,j) = singclap_pdivide( MATELEM(m,i,j) ,
1234	q /(poly)(v->Data())/ );
1235	#else
1236	WerrorS("division only by a monomial");
1237	return TRUE;
1238	#endif
1239	}
1240	else
1241	MATELEM(mm,i,j) = pDivideM(pCopy(MATELEM(m,i,j)),pHead(q));
1242	}
1243	}
1244	res->data=(char *)mm;
1245	return FALSE;
1246	}
1247	static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
1248	{
1249	res->data = (char *)((int)((long)u->Data()) == (int)((long)v->Data()));
1250	jjEQUAL_REST(res,u,v);
1251	return FALSE;
1252	}
1253	static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
1254	{
1255	res->data = (char *)mpEqual((matrix)u->Data(),(matrix)v->Data());
1256	jjEQUAL_REST(res,u,v);
1257	return FALSE;
1258	}
1259	static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
1260	{
1261	res->data = (char *)nEqual((number)u->Data(),(number)v->Data());
1262	jjEQUAL_REST(res,u,v);
1263	return FALSE;
1264	}
1265	static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
1266	{
1267	poly p=(poly)u->Data();
1268	poly q=(poly)v->Data();
1269	res->data = (char *) (pEqualPolys(p,q));
1270	jjEQUAL_REST(res,u,v);
1271	return FALSE;
1272	}
1273	static void jjEQUAL_REST(leftv res,leftv u,leftv v)
1274	{
1275	if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
1276	{
1277	int save_iiOp=iiOp;
1278	if (iiOp==NOTEQUAL)
1279	iiExprArith2(res,u->next,EQUAL_EQUAL,v->next);
1280	else
1281	iiExprArith2(res,u->next,iiOp,v->next);
1282	iiOp=save_iiOp;
1283	}
1284	if (iiOp==NOTEQUAL) res->data=(char *)(!(long)res->data);
1285	}
1286	static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
1287	{
1288	res->data = (char *)((long)u->Data() && (long)v->Data());
1289	return FALSE;
1290	}
1291	static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
1292	{
1293	res->data = (char *)((long)u->Data() \|\| (long)v->Data());
1294	return FALSE;
1295	}
1296	static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
1297	{
1298	res->rtyp=u->rtyp; u->rtyp=0;
1299	res->data=u->data; u->data=NULL;
1300	res->name=u->name; u->name=NULL;
1301	res->attribute=u->attribute; u->attribute=NULL;
1302	res->e=u->e; u->e=NULL;
1303	if (res->e==NULL) res->e=jjMakeSub(v);
1304	else
1305	{
1306	Subexpr sh=res->e;
1307	while (sh->next != NULL) sh=sh->next;
1308	sh->next=jjMakeSub(v);
1309	}
1310	return FALSE;
1311	}
1312	static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
1313	{
1314	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
1315	{
1316	WerrorS("indexed object must have a name");
1317	return TRUE;
1318	}
1319	intvec * iv=(intvec *)v->Data();
1320	leftv p=NULL;
1321	int i;
1322	sleftv t;
1323
1324	memset(&t,0,sizeof(t));
1325	t.rtyp=INT_CMD;
1326	for (i=0;i<iv->length(); i++)
1327	{
1328	t.data=(char )(iv)[i];
1329	if (p==NULL)
1330	{
1331	p=res;
1332	}
1333	else
1334	{
1335	p->next=(leftv)omAlloc0Bin(sleftv_bin);
1336	p=p->next;
1337	}
1338	p->rtyp=IDHDL;
1339	p->data=u->data;
1340	p->name=u->name;
1341	p->flag=u->flag;
1342	p->attribute=u->attribute;
1343	p->e=jjMakeSub(&t);
1344	}
1345	u->rtyp=0;
1346	u->data=NULL;
1347	u->name=NULL;
1348	return FALSE;
1349	}
1350	static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
1351	{
1352	poly p=(poly)u->Data();
1353	int i=(int)(long)v->Data();
1354	int j=0;
1355	while (p!=NULL)
1356	{
1357	j++;
1358	if (j==i)
1359	{
1360	res->data=(char *)pHead(p);
1361	return FALSE;
1362	}
1363	pIter(p);
1364	}
1365	return FALSE;
1366	}
1367	static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
1368	{
1369	poly p=(poly)u->Data();
1370	poly r=NULL;
1371	intvec iv=(intvec )v->CopyD(INTVEC_CMD);
1372	int i;
1373	int sum=0;
1374	for(i=iv->length()-1;i>=0;i--)
1375	sum+=(*iv)[i];
1376	int j=0;
1377	while ((p!=NULL) && (sum>0))
1378	{
1379	j++;
1380	for(i=iv->length()-1;i>=0;i--)
1381	{
1382	if (j==(*iv)[i])
1383	{
1384	r=pAdd(r,pHead(p));
1385	sum-=j;
1386	(*iv)[i]=0;
1387	break;
1388	}
1389	}
1390	pIter(p);
1391	}
1392	delete iv;
1393	res->data=(char *)r;
1394	return FALSE;
1395	}
1396	static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
1397	{
1398	poly p=(poly)u->CopyD(VECTOR_CMD);
1399	poly r=p; // pointer to the beginning of component i
1400	poly o=NULL;
1401	int i=(int)(long)v->Data();
1402	while (p!=NULL)
1403	{
1404	if (pGetComp(p)!=i)
1405	{
1406	if (r==p) r=pNext(p);
1407	if (o!=NULL)
1408	{
1409	pDeleteLm(&pNext(o));
1410	p=pNext(o);
1411	}
1412	else
1413	pDeleteLm(&p);
1414	}
1415	else
1416	{
1417	pSetComp(p, 0);
1418	o=p;
1419	p=pNext(o);
1420	}
1421	}
1422	res->data=(char *)r;
1423	return FALSE;
1424	}
1425	static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
1426	{
1427	poly p=(poly)u->CopyD(VECTOR_CMD);
1428	if (p!=NULL)
1429	{
1430	poly r=pOne();
1431	poly hp=r;
1432	intvec iv=(intvec )v->Data();
1433	int i;
1434	loop
1435	{
1436	for(i=0;i<iv->length();i++)
1437	{
1438	if (pGetComp(p)==(*iv)[i])
1439	{
1440	poly h;
1441	pSplit(p,&h);
1442	pNext(hp)=p;
1443	p=h;
1444	pIter(hp);
1445	break;
1446	}
1447	}
1448	if (p==NULL) break;
1449	if (i==iv->length())
1450	{
1451	pDeleteLm(&p);
1452	if (p==NULL) break;
1453	}
1454	}
1455	pDeleteLm(&r);
1456	res->data=(char *)r;
1457	}
1458	return FALSE;
1459	}
1460	static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v);
1461	static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
1462	{
1463	if(u->name==NULL) return TRUE;
1464	char * nn = (char *)omAlloc(strlen(u->name) + 14);
1465	sprintf(nn,"%s(%d)",u->name,(int)(long)v->Data());
1466	omFree((ADDRESS)u->name);
1467	u->name=NULL;
1468	char *n=omStrDup(nn);
1469	omFree((ADDRESS)nn);
1470	syMake(res,n);
1471	if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1472	return FALSE;
1473	}
1474	static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
1475	{
1476	intvec * iv=(intvec *)v->Data();
1477	leftv p=NULL;
1478	int i;
1479	int slen = strlen(u->name) + 14;
1480	char n = (char) omAlloc(slen);
1481
1482	for (i=0;i<iv->length(); i++)
1483	{
1484	if (p==NULL)
1485	{
1486	p=res;
1487	}
1488	else
1489	{
1490	p->next=(leftv)omAlloc0Bin(sleftv_bin);
1491	p=p->next;
1492	}
1493	sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1494	syMake(p,omStrDup(n));
1495	}
1496	omFree((ADDRESS)u->name);
1497	u->name = NULL;
1498	omFreeSize(n, slen);
1499	if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1500	return FALSE;
1501	}
1502	static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v)
1503	{
1504	leftv tmp=(leftv)omAllocBin(sleftv_bin);
1505	memset(tmp,0,sizeof(sleftv));
1506	BOOLEAN b;
1507	if (v->Typ()==INTVEC_CMD)
1508	b=jjKLAMMER_IV(tmp,u,v);
1509	else
1510	b=jjKLAMMER(tmp,u,v);
1511	if (b)
1512	{
1513	omFreeBin(tmp,sleftv_bin);
1514	return TRUE;
1515	}
1516	leftv h=res;
1517	while (h->next!=NULL) h=h->next;
1518	h->next=tmp;
1519	return FALSE;
1520	}
1521	static BOOLEAN jjPROC(leftv res, leftv u, leftv v)
1522	{
1523	idrec tmp_proc;
1524	Subexpr e;
1525	void *d;
1526	int typ;
1527	BOOLEAN t=FALSE;
1528	if (u->rtyp!=IDHDL)
1529	{
1530	tmp_proc.id="_auto";
1531	tmp_proc.typ=PROC_CMD;
1532	tmp_proc.data.pinf=(procinfo *)u->Data();
1533	tmp_proc.ref=1;
1534	d=u->data; u->data=(void *)&tmp_proc;
1535	e=u->e; u->e=NULL;
1536	t=TRUE;
1537	typ=u->rtyp; u->rtyp=IDHDL;
1538	}
1539	#ifdef HAVE_NS
1540	leftv sl;
1541	if (u->req_packhdl==currPack)
1542	sl = iiMake_proc((idhdl)u->data,NULL,v);
1543	else
1544	sl = iiMake_proc((idhdl)u->data,u->req_packhdl,v);
1545	#else /* HAVE_NS */
1546	leftv sl = iiMake_proc((idhdl)u->data,v);
1547	#endif /* HAVE_NS */
1548	if (t)
1549	{
1550	u->rtyp=typ;
1551	u->data=d;
1552	u->e=e;
1553	}
1554	if (sl==NULL)
1555	{
1556	return TRUE;
1557	}
1558	else
1559	{
1560	memcpy(res,sl,sizeof(sleftv));
1561	}
1562	return FALSE;
1563	}
1564	static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
1565	{
1566	//Print("try to map %s with %s\n",$3.Name(),$1.Name());
1567	leftv sl=NULL;
1568	if ((v->e==NULL)&&(v->name!=NULL))
1569	{
1570	map m=(map)u->Data();
1571	sl=iiMap(m,v->name);
1572	}
1573	else
1574	{
1575	Werror("%s(<name>) expected",u->Name());
1576	}
1577	if (sl==NULL) return TRUE;
1578	memcpy(res,sl,sizeof(sleftv));
1579	omFreeBin((ADDRESS)sl, sleftv_bin);
1580	return FALSE;
1581	}
1582	static BOOLEAN jjCALL2MANY(leftv res, leftv u, leftv v)
1583	{
1584	u->next=(leftv)omAllocBin(sleftv_bin);
1585	memcpy(u->next,v,sizeof(sleftv));
1586	BOOLEAN r=iiExprArithM(res,u,iiOp);
1587	// iiExprArithM did the CleanUp
1588	return r;
1589	}
1590	static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
1591	{
1592	poly p=(poly)v->Data();
1593	if ((p==NULL)\|\|(pNext(p)!=NULL)) return TRUE;
1594	res->data=(char )mpCoeffProc((poly)u->Data(),p /(poly)v->Data()*/);
1595	return FALSE;
1596	}
1597	static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
1598	{
1599	int i=pVar((poly)v->Data());
1600	if (i==0)
1601	{
1602	WerrorS("ringvar expected");
1603	return TRUE;
1604	}
1605	res->data=(char *)mpCoeffs((ideal)u->CopyD(),i);
1606	return FALSE;
1607	}
1608	static BOOLEAN jjCOEFFS2_KB(leftv res, leftv u, leftv v)
1609	{
1610	poly p = pInit();
1611	int i;
1612
1613	for (i=1; i<=pVariables; i++)
1614	{
1615	pSetExp(p, i, 1);
1616	}
1617	pSetm(p);
1618	res->data = (void*)idCoeffOfKBase((ideal)(u->Data()),
1619	(ideal)(v->Data()), p);
1620	pDelete(&p);
1621	return FALSE;
1622	}
1623	static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
1624	{
1625	res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1626	return FALSE;
1627	}
1628	static BOOLEAN jjDEG_M_IV(leftv res, leftv u, leftv v)
1629	{
1630	short iv=iv2array((intvec )v->Data());
1631	ideal I=(ideal)u->Data();
1632	int d=-1;
1633	int i;
1634	for(i=IDELEMS(I);i>=0;i--) d=si_max(d,(int)pDegW(I->m[i],iv));
1635	omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1636	res->data = (char *)d;
1637	return FALSE;
1638	}
1639	static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
1640	{
1641	short iv=iv2array((intvec )v->Data());
1642	res->data = (char *)pDegW((poly)u->Data(),iv);
1643	omFreeSize((ADDRESS)iv,(pVariables+1)*sizeof(short));
1644	return FALSE;
1645	}
1646	static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
1647	{
1648	int i=pVar((poly)v->Data());
1649	if (i==0)
1650	{
1651	WerrorS("ringvar expected");
1652	return TRUE;
1653	}
1654	res->data=(char *)pDiff((poly)(u->Data()),i);
1655	return FALSE;
1656	}
1657	static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
1658	{
1659	int i=pVar((poly)v->Data());
1660	if (i==0)
1661	{
1662	WerrorS("ringvar expected");
1663	return TRUE;
1664	}
1665	res->data=(char *)idDiff((matrix)(u->Data()),i);
1666	return FALSE;
1667	}
1668	static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
1669	{
1670	res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1671	return FALSE;
1672	}
1673	static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
1674	{
1675	assumeStdFlag(v);
1676	if(currQuotient==NULL)
1677	res->data = (char *)scDimInt((ideal)(v->Data()),(ideal)w->Data());
1678	else
1679	{
1680	ideal q=idSimpleAdd(currQuotient,(ideal)w->Data());
1681	res->data = (char *)scDimInt((ideal)(v->Data()),q);
1682	idDelete(&q);
1683	}
1684	return FALSE;
1685	}
1686	static BOOLEAN jjDIVISION(leftv res, leftv u, leftv v)
1687	{
1688	ideal vi=(ideal)v->Data();
1689	int vl= IDELEMS(vi);
1690	ideal ui=(ideal)u->Data();
1691	int ul= IDELEMS(ui);
1692	ideal R; matrix U;
1693	ideal m = idLift(vi,ui,&R, FALSE,hasFlag(v,FLAG_STD),TRUE,&U);
1694	// now make sure that all matices have the corect size:
1695	matrix T = idModule2formatedMatrix(m,vl,ul);
1696	if (MATCOLS(U) != ul)
1697	{
1698	int mul=si_min(ul,MATCOLS(U));
1699	matrix UU=mpNew(ul,ul);
1700	int i,j;
1701	for(i=mul;i>0;i--)
1702	{
1703	for(j=mul;j>0;j--)
1704	{
1705	MATELEM(UU,i,j)=MATELEM(U,i,j);
1706	MATELEM(U,i,j)=NULL;
1707	}
1708	}
1709	idDelete((ideal *)&U);
1710	U=UU;
1711	}
1712	lists L=(lists)omAllocBin(slists_bin);
1713	L->Init(3);
1714	L->m[0].rtyp=MATRIX_CMD; L->m[0].data=(void *)T;
1715	L->m[1].rtyp=u->Typ(); L->m[1].data=(void *)R;
1716	L->m[2].rtyp=MATRIX_CMD; L->m[2].data=(void *)U;
1717	res->data=(char *)L;
1718	return FALSE;
1719	}
1720	static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
1721	{
1722	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1723	setFlag(res,FLAG_STD);
1724	return FALSE;
1725	}
1726	static BOOLEAN jjEXPORTTO(leftv res, leftv u, leftv v)
1727	{
1728	#ifdef HAVE_NS
1729	//Print("exportto %s -> %s\n",v->Name(),u->Name() );
1730	return iiExport(v,0,(idhdl)u->data);
1731	#else
1732	return TRUE;
1733	#endif
1734	}
1735	static BOOLEAN jjERROR(leftv res, leftv u)
1736	{
1737	WerrorS((char *)u->Data());
1738	return TRUE;
1739	}
1740	static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
1741	{
1742	int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1743	int p0=ABS(uu),p1=ABS(vv);
1744	int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
1745
1746	while ( p1!=0 )
1747	{
1748	q=p0 / p1;
1749	r=p0 % p1;
1750	p0 = p1; p1 = r;
1751	r = g0 - g1 * q;
1752	g0 = g1; g1 = r;
1753	r = f0 - f1 * q;
1754	f0 = f1; f1 = r;
1755	}
1756	int a = f0;
1757	int b = g0;
1758	if ( uu /(int)(long)u->Data()/ < 0 ) a=-a;
1759	if ( vv /(int)(long)v->Data()/ < 0 ) b=-b;
1760	lists L=(lists)omAllocBin(slists_bin);
1761	L->Init(3);
1762	L->m[0].rtyp=INT_CMD; L->m[0].data=(void *)p0;
1763	L->m[1].rtyp=INT_CMD; L->m[1].data=(void *)a;
1764	L->m[2].rtyp=INT_CMD; L->m[2].data=(void *)b;
1765	res->rtyp=LIST_CMD;
1766	res->data=(char *)L;
1767	return FALSE;
1768	}
1769	#ifdef HAVE_FACTORY
1770	static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
1771	{
1772	poly r,pa,pb;
1773	BOOLEAN ret=singclap_extgcd((poly)u->Data(),(poly)v->Data(),r,pa,pb);
1774	if (ret) return TRUE;
1775	lists L=(lists)omAllocBin(slists_bin);
1776	L->Init(3);
1777	res->data=(char *)L;
1778	L->m[0].data=(void *)r;
1779	L->m[0].rtyp=POLY_CMD;
1780	L->m[1].data=(void *)pa;
1781	L->m[1].rtyp=POLY_CMD;
1782	L->m[2].data=(void *)pb;
1783	L->m[2].rtyp=POLY_CMD;
1784	return FALSE;
1785	}
1786	static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
1787	{
1788	ideal_list p,h;
1789	h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL,(ideal)w->Data());
1790	p=h;
1791	int l=0;
1792	while (p!=NULL) { p=p->next;l++; }
1793	lists L=(lists)omAllocBin(slists_bin);
1794	L->Init(l);
1795	l=0;
1796	while(h!=NULL)
1797	{
1798	L->m[l].data=(char *)h->d;
1799	L->m[l].rtyp=IDEAL_CMD;
1800	p=h->next;
1801	omFreeSize(h,sizeof(*h));
1802	h=p;
1803	l++;
1804	}
1805	res->data=(void *)L;
1806	return FALSE;
1807	}
1808	#endif
1809	static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
1810	{
1811	ring r=(ring)u->Data();
1812	idhdl w;
1813	int op=iiOp;
1814	nMapFunc nMap;
1815
1816	if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
1817	{
1818	int *perm=NULL;
1819	int *par_perm=NULL;
1820	int par_perm_size=0;
1821	BOOLEAN bo;
1822	//if (!nSetMap(rInternalChar(r),r->parameter,rPar(r),r->minpoly))
1823	if ((nMap=nSetMap(r))==NULL)
1824	{
1825	if (rEqual(r,currRing))
1826	{
1827	nMap=nCopy;
1828	}
1829	else
1830	// Allow imap/fetch to be make an exception only for:
1831	if ( (rField_is_Q_a(r) && // Q(a..) -> Q(a..) \|\| Q \|\| Zp \|\| Zp(a)
1832	(rField_is_Q() \|\| rField_is_Q_a() \|\|
1833	(rField_is_Zp() \|\| rField_is_Zp_a())))
1834	\|\|
1835	(rField_is_Zp_a(r) && // Zp(a..) -> Zp(a..) \|\| Zp
1836	(rField_is_Zp(currRing, rInternalChar(r)) \|\|
1837	rField_is_Zp_a(currRing, rInternalChar(r)))) )
1838	{
1839	par_perm_size=rPar(r);
1840	BITSET save_test=test;
1841	naSetChar(rInternalChar(r),r);
1842	nSetChar(currRing);
1843	test=save_test;
1844	}
1845	else
1846	{
1847	goto err_fetch;
1848	}
1849	}
1850	if ((iiOp!=FETCH_CMD) \|\| (r->N!=pVariables) \|\| (rPar(r)!=rPar(currRing)))
1851	{
1852	perm=(int )omAlloc0((r->N+1)sizeof(int));
1853	if (par_perm_size!=0)
1854	par_perm=(int )omAlloc0(par_perm_sizesizeof(int));
1855	op=IMAP_CMD;
1856	if (iiOp==IMAP_CMD)
1857	{
1858	maFindPerm(r->names, r->N, r->parameter, r->P,
1859	currRing->names,currRing->N,currRing->parameter, currRing->P,
1860	perm,par_perm, currRing->ch);
1861	}
1862	else
1863	{
1864	int i;
1865	if (par_perm_size!=0)
1866	for(i=si_min(rPar(r),rPar(currRing))-1;i>=0;i--) par_perm[i]=-(i+1);
1867	for(i=si_min(r->N,pVariables);i>0;i--) perm[i]=i;
1868	}
1869	}
1870	if ((iiOp==FETCH_CMD) &&(BVERBOSE(V_IMAP)))
1871	{
1872	int i;
1873	for(i=0;i<si_min(r->N,pVariables);i++)
1874	{
1875	Print("// var nr %d: %s -> %s\n",i,r->names[i],currRing->names[i]);
1876	}
1877	for(i=0;i<si_min(rPar(r),rPar(currRing));i++) // possibly empty loop
1878	{
1879	Print("// par nr %d: %s -> %s\n",
1880	i,r->parameter[i],currRing->parameter[i]);
1881	}
1882	}
1883	sleftv tmpW;
1884	memset(&tmpW,0,sizeof(sleftv));
1885	tmpW.rtyp=IDTYP(w);
1886	tmpW.data=IDDATA(w);
1887	if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
1888	perm,par_perm,par_perm_size,nMap)))
1889	{
1890	Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
1891	}
1892	if (perm!=NULL)
1893	omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
1894	if (par_perm!=NULL)
1895	omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
1896	return bo;
1897	}
1898	else
1899	{
1900	Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
1901	}
1902	return TRUE;
1903	err_fetch:
1904	Werror("no identity map from %s",u->Fullname());
1905	return TRUE;
1906	}
1907	static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
1908	{
1909	/*4
1910	* look for the substring what in the string where
1911	* return the position of the first char of what in where
1912	* or 0
1913	*/
1914	char where=(char )u->Data();
1915	char what=(char )v->Data();
1916	char *found = strstr(where,what);
1917	if (found != NULL)
1918	{
1919	res->data=(char *)((found-where)+1);
1920	}
1921	/else res->data=NULL;/
1922	return FALSE;
1923	}
1924	static BOOLEAN jjFWALK(leftv res, leftv u, leftv v)
1925	{
1926	res->data=(char *)fractalWalkProc(u,v);
1927	setFlag( res, FLAG_STD );
1928	return FALSE;
1929	}
1930	static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
1931	{
1932	int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
1933	int p0=ABS(uu),p1=ABS(vv);
1934	int r;
1935
1936	while ( p1!=0 )
1937	{
1938	r=p0 % p1;
1939	p0 = p1; p1 = r;
1940	}
1941	res->rtyp=INT_CMD;
1942	res->data=(char *)p0;
1943	return FALSE;
1944	}
1945	static BOOLEAN jjGCD_BI(leftv res, leftv u, leftv v)
1946	{
1947	number a=(number) u->Data();
1948	number b=(number) v->Data();
1949	if (nlIsZero(a))
1950	{
1951	if (nlIsZero(b)) res->data=(char *)nlInit(1);
1952	else res->data=(char *)nlCopy(b);
1953	}
1954	else
1955	{
1956	if (nlIsZero(b)) res->data=(char *)nlCopy(a);
1957	else res->data=(char *)nlGcd(a, b, NULL);
1958	}
1959	return FALSE;
1960	}
1961	static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
1962	{
1963	number a=(number) u->Data();
1964	number b=(number) v->Data();
1965	if (nIsZero(a))
1966	{
1967	if (nIsZero(b)) res->data=(char *)nInit(1);
1968	else res->data=(char *)nCopy(b);
1969	}
1970	else
1971	{
1972	if (nIsZero(b)) res->data=(char *)nCopy(a);
1973	else res->data=(char *)nGcd(a, b, currRing);
1974	}
1975	return FALSE;
1976	}
1977	#ifdef HAVE_FACTORY
1978	static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
1979	{
1980	res->data=(void *)singclap_gcd((poly)(u->CopyD(POLY_CMD)),
1981	(poly)(v->CopyD(POLY_CMD)));
1982	return FALSE;
1983	}
1984	#endif
1985	static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
1986	{
1987	assumeStdFlag(u);
1988	intvec module_w=(intvec)atGet(u,"isHomog",INTVEC_CMD);
1989	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient);
1990	switch((int)(long)v->Data())
1991	{
1992	case 1:
1993	res->data=(void *)iv;
1994	return FALSE;
1995	case 2:
1996	res->data=(void *)hSecondSeries(iv);
1997	delete iv;
1998	return FALSE;
1999	}
2000	WerrorS(feNotImplemented);
2001	delete iv;
2002	return TRUE;
2003	}
2004	static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
2005	{
2006	int i=pVar((poly)v->Data());
2007	if (i==0)
2008	{
2009	WerrorS("ringvar expected");
2010	return TRUE;
2011	}
2012	res->data = (char *)pHomogen((poly)u->Data(),i);
2013	return FALSE;
2014	}
2015	static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
2016	{
2017	int i=pVar((poly)v->Data());
2018	if (i==0)
2019	{
2020	WerrorS("ringvar expected");
2021	return TRUE;
2022	}
2023	res->data = (char *)idHomogen((ideal)u->Data(),i);
2024	return FALSE;
2025	}
2026	static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
2027	{
2028	assumeStdFlag(u);
2029	res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
2030	currQuotient);
2031	return FALSE;
2032	}
2033	static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
2034	{
2035	res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
2036	setFlag(res,FLAG_STD);
2037	return FALSE;
2038	}
2039	static BOOLEAN jjJanetBasis2(leftv res, leftv u, leftv v)
2040	{
2041	return jjStdJanetBasis(res,u,(int)(long)v->Data());
2042	}
2043	static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
2044	{
2045	res->data = (char *)pJet((poly)u->CopyD(), (int)(long)v->Data());
2046	return FALSE;
2047	}
2048	static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
2049	{
2050	res->data = (char *)idJet((ideal)u->Data(),(int)(long)v->Data());
2051	return FALSE;
2052	}
2053	static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
2054	{
2055	assumeStdFlag(u);
2056	res->data = (char *)scKBase((int)(long)v->Data(),
2057	(ideal)(u->Data()),currQuotient);
2058	return FALSE;
2059	}
2060	static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
2061	{
2062	return mpKoszul(res, u,v);
2063	}
2064	static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
2065	{
2066	sleftv h;
2067	memset(&h,0,sizeof(sleftv));
2068	h.rtyp=INT_CMD;
2069	h.data=(void *)IDELEMS((ideal)v->Data());
2070	return mpKoszul(res, u, &h, v);
2071	}
2072	static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
2073	{
2074	ideal m;
2075	BITSET save_test=test;
2076	int ul= IDELEMS((ideal)u->Data());
2077	int vl= IDELEMS((ideal)v->Data());
2078	m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD));
2079	res->data = (char *)idModule2formatedMatrix(m,ul,vl);
2080	test=save_test;
2081	return FALSE;
2082	}
2083	static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
2084	{
2085	if ((v->rtyp!=IDHDL)\|\|(v->e!=NULL)) return TRUE;
2086	idhdl h=(idhdl)v->data;
2087	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
2088	res->data = (char *)idLiftStd((ideal)u->Data(),
2089	&(h->data.umatrix),testHomog);
2090	setFlag(res,FLAG_STD);
2091	return FALSE;
2092	}
2093	static BOOLEAN jjLOAD2(leftv res, leftv v, leftv w)
2094	{
2095	return jjLOAD(res, v,(int)(long)w->Data());
2096	}
2097	static BOOLEAN jjMINOR(leftv res, leftv u, leftv v)
2098	{
2099	res->data = (char *)idMinors((matrix)u->Data(),(int)(long)v->Data());
2100	return (res->data==NULL);
2101	}
2102	static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
2103	{
2104	intvec w_u=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2105	tHomog hom=testHomog;
2106	if (w_u!=NULL)
2107	{
2108	w_u=ivCopy(w_u);
2109	hom=isHomog;
2110	}
2111	intvec w_v=(intvec )atGet(v,"isHomog",INTVEC_CMD);
2112	if (w_v!=NULL)
2113	{
2114	w_v=ivCopy(w_v);
2115	hom=isHomog;
2116	}
2117	if ((w_u!=NULL) && (w_v==NULL))
2118	w_v=ivCopy(w_u);
2119	if ((w_v!=NULL) && (w_u==NULL))
2120	w_u=ivCopy(w_v);
2121	ideal u_id=(ideal)u->Data();
2122	ideal v_id=(ideal)v->Data();
2123	if (w_u!=NULL)
2124	{
2125	if ((*w_u).compare((w_v))!=0)
2126	{
2127	WarnS("incompatible weights");
2128	delete w_u; w_u=NULL;
2129	hom=testHomog;
2130	}
2131	else
2132	{
2133	if ((!idTestHomModule(u_id,currQuotient,w_v))
2134	\|\| (!idTestHomModule(v_id,currQuotient,w_v)))
2135	{
2136	WarnS("wrong weights");
2137	delete w_u; w_u=NULL;
2138	hom=testHomog;
2139	}
2140	}
2141	}
2142	res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2143	if (w_u!=NULL)
2144	{
2145	atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2146	}
2147	delete w_v;
2148	return FALSE;
2149	}
2150	static BOOLEAN jjMOD_BI(leftv res, leftv u, leftv v)
2151	{
2152	number q=(number)v->Data();
2153	if (nlIsZero(q))
2154	{
2155	WerrorS(ii_div_by_0);
2156	return TRUE;
2157	}
2158	res->data =(char *) nlIntMod((number)u->Data(),q);
2159	return FALSE;
2160	}
2161	static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
2162	{
2163	number q=(number)v->Data();
2164	if (nIsZero(q))
2165	{
2166	WerrorS(ii_div_by_0);
2167	return TRUE;
2168	}
2169	res->data =(char *) nIntMod((number)u->Data(),q);
2170	return FALSE;
2171	}
2172	static BOOLEAN jjMONITOR2(leftv res, leftv u,leftv v)
2173	{
2174	char opt=(char )v->Data();
2175	int mode=0;
2176	while(*opt!='\0')
2177	{
2178	if (*opt=='i') mode \|= PROT_I;
2179	else if (*opt=='o') mode \|= PROT_O;
2180	opt++;
2181	}
2182	monitor((char *)(u->Data()),mode);
2183	return FALSE;
2184	}
2185	static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
2186	{
2187	idhdl h=(idhdl)u->data;
2188	int i=(int)(long)v->Data();
2189	int p=0;
2190	if ((0<i)
2191	&& (IDRING(h)->parameter!=NULL)
2192	&& (i<=(p=rPar(IDRING(h)))))
2193	res->data=omStrDup(IDRING(h)->parameter[i-1]);
2194	else
2195	{
2196	Werror("par number %d out of range 1..%d",i,p);
2197	return TRUE;
2198	}
2199	return FALSE;
2200	}
2201
2202	#ifdef HAVE_PLURAL
2203	static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
2204	{
2205	return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing);
2206	}
2207
2208	static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
2209	{
2210	return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing);
2211	}
2212
2213	static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
2214	{
2215	return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing);
2216	}
2217
2218	static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
2219	{
2220	return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing);
2221	}
2222
2223	static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
2224	{
2225	if (rIsPluralRing(currRing))
2226	{
2227	poly p = (poly)a->CopyD(POLY_CMD);
2228	poly q = (poly)b->Data();
2229	res->data = nc_p_Bracket_qq(p,q);
2230	}
2231	else res->data=NULL;
2232	return FALSE;
2233	}
2234
2235	static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
2236	{
2237	/* number, poly, vector, ideal, module, matrix */
2238	ring r = (ring)a->Data();
2239	if (r == currRing)
2240	{
2241	res->data = b->Data();
2242	res->rtyp = b->rtyp;
2243	return FALSE;
2244	}
2245	if (!rIsLikeOpposite(currRing, r))
2246	{
2247	Werror("%s is not an opposite ring to current ring",a->Fullname());
2248	return TRUE;
2249	}
2250	idhdl w;
2251	if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2252	{
2253	int argtype = IDTYP(w);
2254	switch (argtype)
2255	{
2256	case NUMBER_CMD:
2257	{
2258	/* since basefields are equal, we can apply nCopy */
2259	res->data = nCopy((number)IDDATA(w));
2260	res->rtyp = argtype;
2261	break;
2262	}
2263	case POLY_CMD:
2264	case VECTOR_CMD:
2265	{
2266	poly q = (poly)IDDATA(w);
2267	res->data = pOppose(r,q);
2268	res->rtyp = argtype;
2269	break;
2270	}
2271	case IDEAL_CMD:
2272	case MODUL_CMD:
2273	{
2274	ideal Q = (ideal)IDDATA(w);
2275	res->data = idOppose(r,Q);
2276	res->rtyp = argtype;
2277	break;
2278	}
2279	case MATRIX_CMD:
2280	{
2281	ring save = currRing;
2282	rChangeCurrRing(r);
2283	matrix m = (matrix)IDDATA(w);
2284	ideal Q = idMatrix2Module(mpCopy(m));
2285	rChangeCurrRing(save);
2286	ideal S = idOppose(r,Q);
2287	id_Delete(&Q, r);
2288	res->data = idModule2Matrix(S);
2289	res->rtyp = argtype;
2290	break;
2291	}
2292	default:
2293	{
2294	WerrorS("unsupported type in oppose");
2295	return TRUE;
2296	}
2297	}
2298	}
2299	else
2300	{
2301	Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
2302	return TRUE;
2303	}
2304	return FALSE;
2305	}
2306	#endif /* HAVE_PLURAL */
2307
2308	static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
2309	{
2310	res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
2311	hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
2312	idDelMultiples((ideal)(res->data));
2313	return FALSE;
2314	}
2315	static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
2316	{
2317	int i=(int)(long)u->Data();
2318	int j=(int)(long)v->Data();
2319	#ifdef buildin_rand
2320	res->data =(char *)((i > j) ? i : (siRand() % (j-i+1)) + i);
2321	#else
2322	res->data =(char *)((i > j) ? i : (rand() % (j-i+1)) + i);
2323	#endif
2324	return FALSE;
2325	}
2326	static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
2327	{
2328	si_link l=(si_link)u->Data();
2329	leftv r=slRead(l,v);
2330	if (r==NULL)
2331	{
2332	const char *s;
2333	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
2334	else s=sNoName;
2335	Werror("cannot read from `%s`",s);
2336	return TRUE;
2337	}
2338	memcpy(res,r,sizeof(sleftv));
2339	omFreeBin((ADDRESS)r, sleftv_bin);
2340	return FALSE;
2341	}
2342	static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
2343	{
2344	assumeStdFlag(v);
2345	res->data = (char *)kNF((ideal)v->Data(),currQuotient,(poly)u->Data());
2346	return FALSE;
2347	}
2348	static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
2349	{
2350	assumeStdFlag(v);
2351	ideal ui=(ideal)u->Data();
2352	idTest(ui);
2353	ideal vi=(ideal)v->Data();
2354	idTest(vi);
2355	res->data = (char *)kNF(vi,currQuotient,ui);
2356	return FALSE;
2357	}
2358	#if 0
2359	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2360	{
2361	int maxl=(int)(long)v->Data();
2362	if (maxl<0)
2363	{
2364	WerrorS("length for res must not be negative");
2365	return TRUE;
2366	}
2367	int l=0;
2368	//resolvente r;
2369	syStrategy r;
2370	intvec *weights=NULL;
2371	int wmaxl=maxl;
2372	ideal u_id=(ideal)u->Data();
2373
2374	maxl--;
2375	if ((maxl==-1) /&& (iiOp!=MRES_CMD)/)
2376	{
2377	maxl = pVariables-1+2*(iiOp==MRES_CMD);
2378	if (currQuotient!=NULL)
2379	{
2380	Warn(
2381	"full resolution in a qring may be infinite, setting max length to %d",
2382	maxl+1);
2383	}
2384	}
2385	weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2386	if (weights!=NULL)
2387	{
2388	if (!idTestHomModule(u_id,currQuotient,weights))
2389	{
2390	WarnS("wrong weights given:");weights->show();PrintLn();
2391	weights=NULL;
2392	}
2393	}
2394
2395	intvec *ww=NULL;
2396	int add_row_shift=0;
2397	if (weights!=NULL)
2398	{
2399	ww=ivCopy(weights);
2400	add_row_shift = ww->min_in();
2401	(*ww) -= add_row_shift;
2402	}
2403	else
2404	idHomModule(u_id,currQuotient,&ww);
2405	weights=ww;
2406
2407	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
2408	{
2409	r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2410	}
2411	else if (iiOp==SRES_CMD)
2412	// r=sySchreyerResolvente(u_id,maxl+1,&l);
2413	r=sySchreyer(u_id,maxl+1);
2414	else if (iiOp == LRES_CMD)
2415	{
2416	int dummy;
2417	if((currQuotient!=NULL)\|\|
2418	(!idHomIdeal (u_id,NULL)))
2419	{
2420	WerrorS
2421	("`lres` not implemented for inhomogeneous input or qring");
2422	return TRUE;
2423	}
2424	r=syLaScala3(u_id,&dummy);
2425	}
2426	else if (iiOp == KRES_CMD)
2427	{
2428	int dummy;
2429	if((currQuotient!=NULL)\|\|
2430	(!idHomIdeal (u_id,NULL)))
2431	{
2432	WerrorS
2433	("`kres` not implemented for inhomogeneous input or qring");
2434	return TRUE;
2435	}
2436	r=syKosz(u_id,&dummy);
2437	}
2438	else
2439	{
2440	int dummy;
2441	if((currQuotient!=NULL)\|\|
2442	(!idHomIdeal (u_id,NULL)))
2443	{
2444	WerrorS
2445	("`hres` not implemented for inhomogeneous input or qring");
2446	return TRUE;
2447	}
2448	r=syHilb(u_id,&dummy);
2449	}
2450	if (r==NULL) return TRUE;
2451	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2452	r->list_length=wmaxl;
2453	res->data=(void *)r;
2454	if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2455	{
2456	intvec *w=ivCopy(r->weights[0]);
2457	if (weights!=NULL) (*w) += add_row_shift;
2458	atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2459	delete w;
2460	}
2461	else
2462	{
2463	//#if 0
2464	// need to set weights for ALL components (sres)
2465	if (weights!=NULL)
2466	{
2467	atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2468	r->weights = (intvec**)omAlloc0Bin(void_ptr_bin);
2469	(r->weights)[0] = ivCopy(weights);
2470	}
2471	//#endif
2472	}
2473	if (ww!=NULL) { delete ww; ww=NULL; }
2474	return FALSE;
2475	}
2476	#else
2477	static BOOLEAN jjRES(leftv res, leftv u, leftv v)
2478	{
2479	int maxl=(int)(long)v->Data();
2480	if (maxl<0)
2481	{
2482	WerrorS("length for res must not be negative");
2483	return TRUE;
2484	}
2485	int l=0;
2486	//resolvente r;
2487	syStrategy r;
2488	intvec *weights=NULL;
2489	int wmaxl=maxl;
2490	ideal u_id=(ideal)u->Data();
2491
2492	maxl--;
2493	if ((maxl==-1) /&& (iiOp!=MRES_CMD)/)
2494	{
2495	maxl = pVariables-1+2*(iiOp==MRES_CMD);
2496	if (currQuotient!=NULL)
2497	{
2498	Warn(
2499	"full resolution in a qring may be infinite, setting max length to %d",
2500	maxl+1);
2501	}
2502	}
2503	weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2504	if (weights!=NULL)
2505	{
2506	if (!idTestHomModule(u_id,currQuotient,weights))
2507	{
2508	WarnS("wrong weights given:");weights->show();PrintLn();
2509	weights=NULL;
2510	}
2511	}
2512	intvec *ww=NULL;
2513	int add_row_shift=0;
2514	if (weights!=NULL)
2515	{
2516	ww=ivCopy(weights);
2517	add_row_shift = ww->min_in();
2518	(*ww) -= add_row_shift;
2519	}
2520
2521	if ((iiOp == RES_CMD) \|\| (iiOp == MRES_CMD))
2522	{
2523	r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
2524	}
2525	else if (iiOp==SRES_CMD)
2526	// r=sySchreyerResolvente(u_id,maxl+1,&l);
2527	r=sySchreyer(u_id,maxl+1);
2528	else if (iiOp == LRES_CMD)
2529	{
2530	int dummy;
2531	if((currQuotient!=NULL)\|\|
2532	(!idHomIdeal (u_id,NULL)))
2533	{
2534	WerrorS
2535	("`lres` not implemented for inhomogeneous input or qring");
2536	return TRUE;
2537	}
2538	r=syLaScala3(u_id,&dummy);
2539	}
2540	else if (iiOp == KRES_CMD)
2541	{
2542	int dummy;
2543	if((currQuotient!=NULL)\|\|
2544	(!idHomIdeal (u_id,NULL)))
2545	{
2546	WerrorS
2547	("`kres` not implemented for inhomogeneous input or qring");
2548	return TRUE;
2549	}
2550	r=syKosz(u_id,&dummy);
2551	}
2552	else
2553	{
2554	int dummy;
2555	if((currQuotient!=NULL)\|\|
2556	(!idHomIdeal (u_id,NULL)))
2557	{
2558	WerrorS
2559	("`hres` not implemented for inhomogeneous input or qring");
2560	return TRUE;
2561	}
2562	r=syHilb(u_id,&dummy);
2563	}
2564	if (r==NULL) return TRUE;
2565	//res->data=(void *)liMakeResolv(r,l,wmaxl,u->Typ(),weights);
2566	r->list_length=wmaxl;
2567	res->data=(void *)r;
2568	if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
2569	if ((r->weights!=NULL) && (r->weights[0]!=NULL))
2570	{
2571	ww=ivCopy(r->weights[0]);
2572	if (weights!=NULL) (*ww) += add_row_shift;
2573	atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
2574	}
2575	else
2576	{
2577	if (weights!=NULL)
2578	{
2579	atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
2580	}
2581	}
2582	return FALSE;
2583	}
2584	#endif
2585	static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
2586	{
2587	ring r;
2588	int i=rSum((ring)u->Data(),(ring)v->Data(),r);
2589	res->data = (char *)r;
2590	return (i==-1);
2591	}
2592	#define SIMPL_LMDIV 32
2593	#define SIMPL_LMEQ 16
2594	#define SIMPL_MULT 8
2595	#define SIMPL_EQU 4
2596	#define SIMPL_NULL 2
2597	#define SIMPL_NORM 1
2598	static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
2599	{
2600	int sw = (int)(long)v->Data();
2601	// CopyD for IDEAL_CMD and MODUL_CMD are identical:
2602	ideal id = (ideal)u->CopyD(IDEAL_CMD);
2603	if (sw & SIMPL_LMDIV)
2604	{
2605	idDelDiv(id);
2606	}
2607	if (sw & SIMPL_LMEQ)
2608	{
2609	idDelLmEquals(id);
2610	}
2611	if (sw & SIMPL_NULL)
2612	{
2613	idSkipZeroes(id);
2614	}
2615	if (sw & SIMPL_NORM)
2616	{
2617	idNorm(id);
2618	}
2619	if (sw & SIMPL_MULT)
2620	{
2621	idDelMultiples(id);
2622	}
2623	else if(sw & SIMPL_EQU)
2624	{
2625	idDelEquals(id);
2626	}
2627	res->data = (char * )id;
2628	return FALSE;
2629	}
2630	#ifdef HAVE_FACTORY
2631	extern int singclap_factorize_retry;
2632	static BOOLEAN jjSQR_FREE_DEC(leftv res, leftv u,leftv dummy)
2633	{
2634	intvec *v=NULL;
2635	int sw=(int)(long)dummy->Data();
2636	int fac_sw=sw;
2637	if ((sw<0)\|\|(sw>2)) fac_sw=1;
2638	singclap_factorize_retry=0;
2639	ideal f=singclap_factorize((poly)(u->Data()), &v, fac_sw);
2640	if (f==NULL)
2641	return TRUE;
2642	switch(sw)
2643	{
2644	case 0:
2645	case 2:
2646	{
2647	lists l=(lists)omAllocBin(slists_bin);
2648	l->Init(2);
2649	l->m[0].rtyp=IDEAL_CMD;
2650	l->m[0].data=(void *)f;
2651	l->m[1].rtyp=INTVEC_CMD;
2652	l->m[1].data=(void *)v;
2653	res->data=(void *)l;
2654	res->rtyp=LIST_CMD;
2655	return FALSE;
2656	}
2657	case 1:
2658	res->data=(void *)f;
2659	return FALSE;
2660	case 3:
2661	{
2662	poly p=f->m[0];
2663	int i=IDELEMS(f);
2664	f->m[0]=NULL;
2665	while(i>1)
2666	{
2667	i--;
2668	p=pMult(p,f->m[i]);
2669	f->m[i]=NULL;
2670	}
2671	res->data=(void *)p;
2672	res->rtyp=POLY_CMD;
2673	}
2674	return FALSE;
2675	}
2676	WerrorS("invalid switch");
2677	return TRUE;
2678	}
2679	#endif
2680	static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
2681	{
2682	res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
2683	return FALSE;
2684	}
2685	static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
2686	{
2687	int sw = (int)(long)v->Data();
2688	// CopyD for POLY_CMD and VECTOR_CMD are identical:
2689	poly p = (poly)u->CopyD(POLY_CMD);
2690	if (sw & SIMPL_NORM)
2691	{
2692	pNorm(p);
2693	}
2694	res->data = (char * )p;
2695	return FALSE;
2696	}
2697	static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
2698	{
2699	ideal result;
2700	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2701	tHomog hom=testHomog;
2702	ideal u_id=(ideal)(u->Data());
2703	if (w!=NULL)
2704	{
2705	if (!idTestHomModule(u_id,currQuotient,w))
2706	{
2707	WarnS("wrong weights");
2708	w=NULL;
2709	}
2710	else
2711	{
2712	w=ivCopy(w);
2713	hom=isHomog;
2714	}
2715	}
2716	result=kStd(u_id,currQuotient,hom,&w,(intvec *)v->Data());
2717	idSkipZeroes(result);
2718	res->data = (char *)result;
2719	setFlag(res,FLAG_STD);
2720	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2721	return FALSE;
2722	}
2723	static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
2724	{
2725	ideal result;
2726	assumeStdFlag(u);
2727	ideal i1=(ideal)(u->Data());
2728	ideal i0;
2729	int r=v->Typ();
2730	if ((/v->Typ()/r==POLY_CMD) \|\|(r==VECTOR_CMD))
2731	{
2732	i0=idInit(1,i1->rank);
2733	i0->m[0]=(poly)v->Data();
2734	}
2735	else /IDEAL/
2736	{
2737	i0=(ideal)v->Data();
2738	}
2739	i1=idSimpleAdd(i1,i0);
2740	memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
2741	idDelete(&i0);
2742	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
2743	tHomog hom=testHomog;
2744	if (w!=NULL)
2745	{
2746	if (!idTestHomModule(i1,currQuotient,w))
2747	{
2748	// no warnung: this is legal, if i in std(i,p)
2749	// is homogeneous, but p not
2750	w=NULL;
2751	}
2752	else
2753	{
2754	w=ivCopy(w);
2755	hom=isHomog;
2756	}
2757	}
2758	BITSET save_test=test;
2759	test\|=Sy_bit(OPT_SB_1);
2760	result=kStd(i1,currQuotient,hom,&w,NULL,0,IDELEMS(i1)-1);
2761	test=save_test;
2762	idDelete(&i1);
2763	idSkipZeroes(result);
2764	res->data = (char *)result;
2765	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
2766	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
2767	return FALSE;
2768	}
2769	static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
2770	{
2771	idhdl h=(idhdl)u->data;
2772	int i=(int)(long)v->Data();
2773	if ((0<i) && (i<=IDRING(h)->N))
2774	res->data=omStrDup(IDRING(h)->names[i-1]);
2775	else
2776	{
2777	Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
2778	return TRUE;
2779	}
2780	return FALSE;
2781	}
2782	static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
2783	{
2784	res->data = (char *)mpWedge((matrix)u->Data(),(int)(long)v->Data());
2785	return FALSE;
2786	}
2787	#define jjWRONG2 (proc2)jjWRONG
2788	#define jjWRONG3 (proc3)jjWRONG
2789	static BOOLEAN jjWRONG(leftv res, leftv u)
2790	{
2791	return TRUE;
2792	}
2793
2794	static BOOLEAN jjLOAD_E(leftv res, leftv v, leftv u)
2795	{
2796	char * s=(char *)u->Data();
2797	if(strcmp(s, "with")==0)
2798	return jjLOAD(res, v, TRUE);
2799	WerrorS("invalid second argument");
2800	WerrorS("load(\"libname\" [,\"with\"]);");
2801	return TRUE;
2802	}
2803
2804	/=================== operations with 2 args.: table =================/
2805
2806	struct sValCmd2 dArith2[]=
2807	{
2808	// operations:
2809	// proc cmd res arg1 arg2 plural
2810	{jjCOLCOL, COLONCOLON, ANY_TYPE, DEF_CMD, DEF_CMD ALLOW_PLURAL}
2811	,{jjPLUS_I, '+', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2812	,{jjPLUS_BI, '+', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2813	,{jjPLUS_N, '+', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2814	,{jjPLUS_P, '+', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2815	,{jjPLUS_P, '+', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2816	,{jjPLUS_ID, '+', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2817	,{jjPLUS_ID, '+', MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2818	,{jjPLUS_P_MA, '+', MATRIX_CMD, POLY_CMD, MATRIX_CMD ALLOW_PLURAL}
2819	,{jjPLUS_MA_P, '+', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2820	,{jjPLUS_MA, '+', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2821	,{jjPLUS_S, '+', STRING_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2822	,{jjOP_IV_I, '+', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2823	,{jjOP_I_IV, '+', INTVEC_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
2824	,{jjOP_IM_I, '+', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2825	,{jjOP_I_IM, '+', INTMAT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
2826	,{jjPLUS_IV, '+', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2827	,{jjPLUS_IV, '+', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2828	,{lAdd, '+', LIST_CMD, LIST_CMD, LIST_CMD ALLOW_PLURAL}
2829	,{jjRSUM, '+', RING_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
2830	,{jjRSUM, '+', QRING_CMD, QRING_CMD, RING_CMD ALLOW_PLURAL}
2831	,{jjRSUM, '+', QRING_CMD, RING_CMD, QRING_CMD ALLOW_PLURAL}
2832	,{jjRSUM, '+', QRING_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
2833	,{jjMINUS_I, '-', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2834	,{jjMINUS_BI, '-', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2835	,{jjMINUS_N, '-', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2836	,{jjMINUS_P, '-', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2837	,{jjMINUS_P, '-', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2838	,{jjPLUS_MA_P, '-', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2839	,{jjMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2840	,{jjOP_IV_I, '-', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2841	,{jjOP_IM_I, '-', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2842	,{jjMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2843	,{jjMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2844	,{jjTIMES_I, '*', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2845	,{jjTIMES_BI, '*', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2846	,{jjTIMES_N, '*', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2847	,{jjTIMES_P, '*', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2848	,{jjTIMES_P, '*', VECTOR_CMD, POLY_CMD, VECTOR_CMD ALLOW_PLURAL}
2849	,{jjTIMES_P, '*', VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2850	,{jjTIMES_MA_P1,'*', IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
2851	,{jjTIMES_MA_P2,'*', IDEAL_CMD, POLY_CMD, IDEAL_CMD ALLOW_PLURAL}
2852	,{jjTIMES_ID, '*', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2853	,{jjTIMES_MA_P1,'*', MODUL_CMD, IDEAL_CMD, VECTOR_CMD ALLOW_PLURAL}
2854	,{jjTIMES_MA_P2,'*', MODUL_CMD, VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
2855	,{jjTIMES_ID, '*', MODUL_CMD, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2856	,{jjTIMES_ID, '*', MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2857	,{jjTIMES_MA_P1,'*', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2858	,{jjTIMES_MA_P2,'*', MATRIX_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
2859	,{jjTIMES_MA_N1,'*', MATRIX_CMD, MATRIX_CMD, NUMBER_CMD ALLOW_PLURAL}
2860	,{jjTIMES_MA_N2,'*', MATRIX_CMD, NUMBER_CMD, MATRIX_CMD ALLOW_PLURAL}
2861	,{jjTIMES_MA_I1,'*', MATRIX_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
2862	,{jjTIMES_MA_I2,'*', MATRIX_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
2863	,{jjTIMES_MA, '*', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2864	,{jjOP_IV_I, '*', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2865	,{jjOP_I_IV, '*', INTVEC_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
2866	,{jjOP_IV_I, '*', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2867	,{jjOP_I_IV, '*', INTMAT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
2868	,{jjTIMES_IV, '*', INTVEC_CMD, INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
2869	,{jjTIMES_IV, '*', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2870	,{jjTIMES_IV, '*', INTMAT_CMD, INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
2871	,{jjDIV_N, '/', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2872	,{jjDIV_P, '/', POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2873	,{jjDIV_P, '/', VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2874	,{jjDIV_Ma, '/', MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2875	,{jjDIVMOD_I, '/', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2876	,{jjDIV_BI, '/', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2877	,{jjOP_IV_I, '/', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2878	,{jjOP_IV_I, '/', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2879	,{jjDIVMOD_I, INTDIV_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2880	,{jjDIV_BI, INTDIV_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2881	,{jjOP_IV_I, INTDIV_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2882	,{jjOP_IV_I, INTDIV_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2883	,{jjDIVMOD_I, '%', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2884	,{jjMOD_BI, '%', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2885	,{jjOP_IV_I, '%', INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2886	,{jjOP_IV_I, '%', INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2887	,{jjMOD_N, '%', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2888	,{jjDIVMOD_I, INTMOD_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2889	,{jjMOD_BI, INTMOD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
2890	,{jjOP_IV_I, INTMOD_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2891	,{jjOP_IV_I, INTMOD_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD ALLOW_PLURAL}
2892	,{jjMOD_N, INTMOD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2893	,{jjPOWER_I, '^', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2894	,{jjPOWER_BI, '^', BIGINT_CMD, BIGINT_CMD, INT_CMD ALLOW_PLURAL}
2895	,{jjPOWER_N, '^', NUMBER_CMD, NUMBER_CMD, INT_CMD ALLOW_PLURAL}
2896	,{jjPOWER_P, '^', POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
2897	,{jjPOWER_ID, '^', IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
2898	,{jjLE_I, LE, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2899	,{jjLE_N, LE, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2900	,{jjCOMPARE_S, LE, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2901	,{jjCOMPARE_IV_I,LE, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2902	,{jjCOMPARE_IV,LE, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2903	,{jjCOMPARE_P, LE, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2904	,{jjCOMPARE_P, LE, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2905	,{jjLT_I, '<', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2906	,{jjLT_N, '<', INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2907	,{jjCOMPARE_IV_I,'<', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2908	,{jjCOMPARE_IV,'<', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2909	,{jjCOMPARE_S, '<', INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2910	,{jjCOMPARE_P, '<', INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2911	,{jjCOMPARE_P, '<', INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2912	,{jjGE_I, GE, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2913	,{jjGE_N, GE, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2914	,{jjCOMPARE_S, GE, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2915	,{jjCOMPARE_IV_I,GE, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2916	,{jjCOMPARE_IV,GE, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2917	,{jjCOMPARE_P, GE, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2918	,{jjCOMPARE_P, GE, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2919	,{jjGT_I, '>', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2920	,{jjGT_N, '>', INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2921	,{jjCOMPARE_S, '>', INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2922	,{jjCOMPARE_IV_I,'>', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2923	,{jjCOMPARE_IV,'>', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2924	,{jjCOMPARE_P, '>', INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2925	,{jjCOMPARE_P, '>', INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2926	,{jjAND_I, '&', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2927	,{jjOR_I, '\|', INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2928	,{jjEQUAL_I, EQUAL_EQUAL, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2929	,{jjEQUAL_N, EQUAL_EQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2930	,{jjCOMPARE_S, EQUAL_EQUAL, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2931	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2932	,{jjEQUAL_P, EQUAL_EQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2933	,{jjCOMPARE_IV_I,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2934	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2935	,{jjCOMPARE_IV,EQUAL_EQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2936	,{jjEQUAL_Ma, EQUAL_EQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2937	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2938	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2939	,{jjWRONG2, EQUAL_EQUAL, 0, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2940	,{jjWRONG2, EQUAL_EQUAL, 0, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2941	,{jjEQUAL_I, NOTEQUAL, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2942	,{jjEQUAL_N, NOTEQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
2943	,{jjCOMPARE_S, NOTEQUAL, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
2944	,{jjEQUAL_P, NOTEQUAL, INT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2945	,{jjEQUAL_P, NOTEQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
2946	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2947	,{jjCOMPARE_IV,NOTEQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
2948	,{jjEQUAL_Ma, NOTEQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
2949	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2950	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2951	,{jjWRONG2, NOTEQUAL, 0, IDEAL_CMD, MODUL_CMD ALLOW_PLURAL}
2952	,{jjWRONG2, NOTEQUAL, 0, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
2953	,{jjDOTDOT, DOTDOT, INTVEC_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
2954	,{jjINDEX_I, '[', INT_CMD, INTVEC_CMD, INT_CMD ALLOW_PLURAL}
2955	,{jjINDEX_IV, '[', INT_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
2956	,{jjINDEX_I, '[', POLY_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
2957	,{jjINDEX_I, '[', POLY_CMD, MAP_CMD, INT_CMD ALLOW_PLURAL}
2958	,{jjINDEX_IV, '[', POLY_CMD, IDEAL_CMD, INTVEC_CMD ALLOW_PLURAL}
2959	,{jjINDEX_I, '[', VECTOR_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
2960	,{jjINDEX_IV, '[', VECTOR_CMD, MODUL_CMD, INTVEC_CMD ALLOW_PLURAL}
2961	,{jjINDEX_I, '[', STRING_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
2962	,{jjINDEX_IV, '[', STRING_CMD, STRING_CMD, INTVEC_CMD ALLOW_PLURAL}
2963	,{jjINDEX_I, '[', ANY_TYPE/set by p/,LIST_CMD, INT_CMD ALLOW_PLURAL}
2964	,{jjINDEX_IV, '[', ANY_TYPE/set by p/,LIST_CMD, INTVEC_CMD ALLOW_PLURAL}
2965	,{jjINDEX_P, '[', POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
2966	,{jjINDEX_P_IV,'[', POLY_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
2967	,{jjINDEX_V, '[', POLY_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
2968	,{jjINDEX_V_IV,'[', VECTOR_CMD, VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2969	,{jjPROC, '(', ANY_TYPE/set by p/,PROC_CMD, DEF_CMD ALLOW_PLURAL}
2970	,{jjMAP, '(', ANY_TYPE/set by p/,MAP_CMD, DEF_CMD ALLOW_PLURAL}
2971	,{jjKLAMMER, '(', ANY_TYPE/set by p/,ANY_TYPE, INT_CMD ALLOW_PLURAL}
2972	,{jjKLAMMER_IV,'(', ANY_TYPE/set by p/,ANY_TYPE, INTVEC_CMD ALLOW_PLURAL}
2973	// and the procedures with 2 arguments:
2974	,{atATTRIB2, ATTRIB_CMD, NONE/set by p/,DEF_CMD, STRING_CMD ALLOW_PLURAL}
2975	,{jjWRONG2, BAREISS_CMD, 0, DEF_CMD, DEF_CMD ALLOW_PLURAL}
2976	,{jjBETTI2, BETTI_CMD, INTMAT_CMD, LIST_CMD, INT_CMD ALLOW_PLURAL}
2977	,{syBetti2, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD, INT_CMD ALLOW_PLURAL}
2978	,{jjBETTI2_ID, BETTI_CMD, INTMAT_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
2979	,{jjBETTI2_ID, BETTI_CMD, INTMAT_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
2980	#ifdef HAVE_PLURAL
2981	,{jjBRACKET, BRACKET_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2982	#endif
2983	,{jjCOEF, COEF_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2984	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
2985	,{jjCOEFFS_Id, COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
2986	,{jjCOEFFS2_KB,COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2987	,{jjCOEFFS2_KB,COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
2988	,{jjCONTRACT, CONTRACT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2989	,{jjDEG_IV, DEG_CMD, INT_CMD, POLY_CMD, INTVEC_CMD ALLOW_PLURAL}
2990	,{jjDEG_IV, DEG_CMD, INT_CMD, VECTOR_CMD, INTVEC_CMD ALLOW_PLURAL}
2991	,{jjDEG_M_IV, DEG_CMD, INT_CMD, MATRIX_CMD, INTVEC_CMD ALLOW_PLURAL}
2992	,{lDelete, DELETE_CMD, LIST_CMD, LIST_CMD, INT_CMD ALLOW_PLURAL}
2993	,{jjDIFF_P, DIFF_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
2994	,{jjDIFF_P, DIFF_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
2995	,{jjDIFF_ID, DIFF_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
2996	,{jjDIFF_ID_ID,DIFF_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
2997	,{jjDIFF_ID, DIFF_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
2998	,{jjDIFF_ID, DIFF_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD ALLOW_PLURAL}
2999	,{jjDIM2, DIM_CMD, INT_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3000	,{jjDIM2, DIM_CMD, INT_CMD, MODUL_CMD, IDEAL_CMD NO_PLURAL}
3001	,{jjDIVISION, DIVISION_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3002	,{jjDIVISION, DIVISION_CMD, LIST_CMD, MODUL_CMD, MODUL_CMD NO_PLURAL}
3003	,{jjELIMIN, ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3004	,{jjELIMIN, ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3005	,{jjEXPORTTO, EXPORTTO_CMD, NONE, PACKAGE_CMD, IDHDL ALLOW_PLURAL}
3006	,{jjEXTGCD_I, EXTGCD_CMD, LIST_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3007	#ifdef HAVE_FACTORY
3008	,{jjEXTGCD_P, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3009	,{jjSQR_FREE_DEC,FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD NO_PLURAL}
3010	,{jjFACSTD2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3011	#else
3012	,{jjWRONG2, EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3013	,{jjWRONG2, FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD NO_PLURAL}
3014	,{jjWRONG2, FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
3015	#endif
3016	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE ALLOW_PLURAL}
3017	,{jjFETCH, FETCH_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3018	#ifdef HAVE_FGLM
3019	,{fglmProc, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3020	,{fglmProc, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD NO_PLURAL}
3021	,{fglmQuotProc,FGLMQUOT_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD NO_PLURAL}
3022	#else
3023	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3024	,{jjWRONG2, FGLM_CMD, IDEAL_CMD, QRING_CMD, DEF_CMD NO_PLURAL}
3025	,{jjWRONG2, FGLMQUOT_CMD, IDEAL_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
3026	#endif
3027	,{jjFIND2, FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3028	,{jjFWALK, FWALK_CMD, IDEAL_CMD, RING_CMD, DEF_CMD NO_PLURAL}
3029
3030	,{jjGCD_I, GCD_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3031	,{jjGCD_N, GCD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
3032	,{jjGCD_BI, GCD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
3033	#if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC_P)
3034	,{jjGCD_P, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3035	#else
3036	,{jjWRONG2, GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD NO_PLURAL}
3037	#endif
3038	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3039	,{jjHILBERT2, HILBERT_CMD, INTVEC_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3040	,{jjHOMOG_P, HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
3041	,{jjHOMOG_P, HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD ALLOW_PLURAL}
3042	,{jjHOMOG_ID, HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3043	,{jjHOMOG_ID, HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD ALLOW_PLURAL}
3044	,{jjRES, HRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3045	,{jjCALL2MANY, IDEAL_CMD, IDEAL_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3046	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,RING_CMD, ANY_TYPE ALLOW_PLURAL}
3047	,{jjFETCH, IMAP_CMD, ANY_TYPE/set by p/,QRING_CMD, ANY_TYPE ALLOW_PLURAL}
3048	,{jjIMPORTFROM,IMPORTFROM_CMD, NONE, PACKAGE_CMD, ANY_TYPE ALLOW_PLURAL}
3049	,{jjINDEPSET2, INDEPSET_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3050	,{lInsert, INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD ALLOW_PLURAL}
3051	#ifdef HAVE_INTERPOLATION
3052	,{jjINTERPOLATION,INTERPOLATE_CMD,IDEAL_CMD, LIST_CMD, INTVEC_CMD NO_PLURAL}
3053	#endif
3054	,{jjINTERSECT, INTERSECT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3055	,{jjINTERSECT, INTERSECT_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3056	,{jjJanetBasis2, JANET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3057	,{jjJET_P, JET_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3058	,{jjJET_ID, JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3059	,{jjJET_P, JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3060	,{jjJET_ID, JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3061	,{jjJET_ID, JET_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD ALLOW_PLURAL}
3062	,{jjKBASE2, KBASE_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3063	,{jjKBASE2, KBASE_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3064	,{atKILLATTR2, KILLATTR_CMD, NONE, IDHDL, STRING_CMD ALLOW_PLURAL}
3065	,{jjKoszul, KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD NO_PLURAL}
3066	,{jjKoszul_Id, KOSZUL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
3067	,{jjRES, KRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3068	,{jjLIFT, LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3069	,{jjLIFT, LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3070	,{jjLIFTSTD, LIFTSTD_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
3071	,{jjLIFTSTD, LIFTSTD_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD ALLOW_PLURAL}
3072	,{jjCALL2MANY, LIST_CMD, LIST_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3073	,{jjLOAD2, LOAD_CMD, NONE, STRING_CMD, INT_CMD ALLOW_PLURAL}
3074	,{jjRES, LRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3075	,{jjMINOR, MINOR_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD NO_PLURAL}
3076	,{jjCALL2MANY, MODUL_CMD, MODUL_CMD, DEF_CMD, DEF_CMD ALLOW_PLURAL}
3077	,{jjMODULO, MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3078	,{jjMODULO, MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3079	,{jjMONITOR2, MONITOR_CMD, NONE, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3080	//,{jjRES, MRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3081	//,{jjRES, MRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3082	,{jjRES, MRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3083	,{jjRES, MRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3084	#ifdef HAVE_PLURAL
3085	,{jjPlural_num_poly, NCALGEBRA_CMD, NONE, POLY_CMD, POLY_CMD NO_PLURAL}
3086	,{jjPlural_num_mat, NCALGEBRA_CMD, NONE, POLY_CMD, MATRIX_CMD NO_PLURAL}
3087	,{jjPlural_mat_poly, NCALGEBRA_CMD, NONE, MATRIX_CMD, POLY_CMD NO_PLURAL}
3088	,{jjPlural_mat_mat, NCALGEBRA_CMD, NONE, MATRIX_CMD, MATRIX_CMD NO_PLURAL}
3089	#endif
3090	#ifdef HAVE_PLURAL
3091	,{jjOPPOSE, OPPOSE_CMD, ANY_TYPE/set by p/, RING_CMD, DEF_CMD ALLOW_PLURAL}
3092	,{jjOPPOSE, OPPOSE_CMD, ANY_TYPE/set by p/, QRING_CMD, DEF_CMD ALLOW_PLURAL}
3093	#endif
3094	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD ALLOW_PLURAL}
3095	,{jjPARSTR2, PARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD ALLOW_PLURAL}
3096	,{jjPRINT_FORMAT, PRINT_CMD, ANY_TYPE, DEF_CMD, STRING_CMD ALLOW_PLURAL}
3097	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3098	,{jjQUOT, QUOTIENT_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3099	,{jjQUOT, QUOTIENT_CMD, IDEAL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3100	,{jjRANDOM, RANDOM_CMD, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
3101	,{jjREAD2, READ_CMD, STRING_CMD, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3102	,{jjREDUCE_P, REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD ALLOW_PLURAL}
3103	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD ALLOW_PLURAL}
3104	,{jjREDUCE_P, REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD ALLOW_PLURAL}
3105	,{jjREDUCE_ID, REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3106	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3107	,{jjREDUCE_ID, REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
3108	//,{jjRES, RES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3109	//,{jjRES, RES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3110	,{jjRES, RES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3111	,{jjRES, RES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3112	,{jjSTATUS2, STATUS_CMD, STRING_CMD, LINK_CMD, STRING_CMD ALLOW_PLURAL}
3113	,{jjSIMPL_P, SIMPLIFY_CMD, POLY_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
3114	,{jjSIMPL_P, SIMPLIFY_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
3115	,{jjSIMPL_ID, SIMPLIFY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD ALLOW_PLURAL}
3116	,{jjSIMPL_ID, SIMPLIFY_CMD, MODUL_CMD, MODUL_CMD, INT_CMD ALLOW_PLURAL}
3117	//,{jjRES, SRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3118	//,{jjRES, SRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3119	,{jjRES, SRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3120	,{jjRES, SRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD NO_PLURAL}
3121	,{jjCALL2MANY, SYSTEM_CMD, ANY_TYPE/set by p/,STRING_CMD, DEF_CMD ALLOW_PLURAL}
3122	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
3123	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, VECTOR_CMD ALLOW_PLURAL}
3124	,{jjSTD_1, STD_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
3125	,{jjSTD_1, STD_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
3126	,{jjSTD_HILB, STD_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD NO_PLURAL}
3127	,{jjSTD_HILB, STD_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD NO_PLURAL}
3128	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD ALLOW_PLURAL}
3129	,{jjVARSTR2, VARSTR_CMD, STRING_CMD, QRING_CMD, INT_CMD ALLOW_PLURAL}
3130	,{jjWEDGE, WEDGE_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD NO_PLURAL}
3131	,{jjLOAD_E, LOAD_CMD, NONE, STRING_CMD, STRING_CMD ALLOW_PLURAL}
3132	,{nuMPResMat, MPRES_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD NO_PLURAL}
3133	,{NULL, 0, 0, 0, 0 NO_PLURAL}
3134	};
3135	/=================== operations with 1 arg.: static proc =================/
3136	static BOOLEAN jjDUMMY(leftv res, leftv u)
3137	{
3138	res->data = (char *)u->CopyD();
3139	return FALSE;
3140	}
3141	static BOOLEAN jjNULL(leftv res, leftv u)
3142	{
3143	return FALSE;
3144	}
3145	//static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3146	//{
3147	// res->data = (char *)((int)(long)u->Data()+1);
3148	// return FALSE;
3149	//}
3150	//static BOOLEAN jjMINUSMINUS(leftv res, leftv u)
3151	//{
3152	// res->data = (char *)((int)(long)u->Data()-1);
3153	// return FALSE;
3154	//}
3155	static BOOLEAN jjPLUSPLUS(leftv res, leftv u)
3156	{
3157	if (IDTYP((idhdl)u->data)==INT_CMD)
3158	{
3159	int i=IDINT((idhdl)u->data);
3160	if (iiOp==PLUSPLUS) i++;
3161	else i--;
3162	IDDATA((idhdl)u->data)=(char *)i;
3163	return FALSE;
3164	}
3165	return TRUE;
3166	}
3167	static BOOLEAN jjUMINUS_I(leftv res, leftv u)
3168	{
3169	res->data = (char *)(-(int)(long)u->Data());
3170	return FALSE;
3171	}
3172	static BOOLEAN jjUMINUS_N(leftv res, leftv u)
3173	{
3174	number n=(number)u->CopyD(NUMBER_CMD);
3175	n=nNeg(n);
3176	res->data = (char *)n;
3177	return FALSE;
3178	}
3179	static BOOLEAN jjUMINUS_P(leftv res, leftv u)
3180	{
3181	res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3182	return FALSE;
3183	}
3184	static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
3185	{
3186	poly m1=pISet(-1);
3187	res->data = (char *)mpMultP((matrix)u->CopyD(MATRIX_CMD),m1);
3188	return FALSE;
3189	}
3190	static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
3191	{
3192	intvec iv=(intvec )u->CopyD(INTVEC_CMD);
3193	(iv)=(-1);
3194	res->data = (char *)iv;
3195	return FALSE;
3196	}
3197	static BOOLEAN jjPROC1(leftv res, leftv u)
3198	{
3199	return jjPROC(res,u,NULL);
3200	}
3201	static BOOLEAN jjBAREISS(leftv res, leftv v)
3202	{
3203	//matrix m=(matrix)v->Data();
3204	//lists l=mpBareiss(m,FALSE);
3205	intvec *iv;
3206	ideal m;
3207	smCallNewBareiss((ideal)v->Data(),0,0,m,&iv);
3208	lists l=(lists)omAllocBin(slists_bin);
3209	l->Init(2);
3210	l->m[0].rtyp=MODUL_CMD;
3211	l->m[1].rtyp=INTVEC_CMD;
3212	l->m[0].data=(void *)m;
3213	l->m[1].data=(void *)iv;
3214	res->data = (char *)l;
3215	return FALSE;
3216	}
3217	//static BOOLEAN jjBAREISS_IM(leftv res, leftv v)
3218	//{
3219	// intvec m=(intvec )v->CopyD(INTMAT_CMD);
3220	// ivTriangMat(m);
3221	// res->data = (char *)m;
3222	// return FALSE;
3223	//}
3224	static BOOLEAN jjCALL1MANY(leftv res, leftv u)
3225	{
3226	return iiExprArithM(res,u,iiOp);
3227	}
3228	static BOOLEAN jjCHAR(leftv res, leftv v)
3229	{
3230	res->data = (char *)rChar((ring)v->Data());
3231	return FALSE;
3232	}
3233	static BOOLEAN jjCOLS(leftv res, leftv v)
3234	{
3235	res->data = (char *)MATCOLS((matrix)(v->Data()));
3236	return FALSE;
3237	}
3238	static BOOLEAN jjCOLS_IV(leftv res, leftv v)
3239	{
3240	res->data = (char )((intvec)(v->Data()))->cols();
3241	return FALSE;
3242	}
3243	static BOOLEAN jjCONTENT(leftv res, leftv v)
3244	{
3245	// CopyD for POLY_CMD and VECTOR_CMD are identical:
3246	poly p=(poly)v->CopyD(POLY_CMD);
3247	if (p!=NULL) pCleardenom(p);
3248	res->data = (char *)p;
3249	return FALSE;
3250	}
3251	static BOOLEAN jjCOUNT_N(leftv res, leftv v)
3252	{
3253	res->data = (char *)nSize((number)v->Data());
3254	return FALSE;
3255	}
3256	static BOOLEAN jjCOUNT_L(leftv res, leftv v)
3257	{
3258	lists l=(lists)v->Data();
3259	res->data = (char *)(l->nr+1);
3260	return FALSE;
3261	}
3262	static BOOLEAN jjCOUNT_M(leftv res, leftv v)
3263	{
3264	matrix m=(matrix)v->Data();
3265	res->data = (char )(MATROWS(m)MATCOLS(m));
3266	return FALSE;
3267	}
3268	static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
3269	{
3270	res->data = (char )((intvec)(v->Data()))->length();
3271	return FALSE;
3272	}
3273	static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
3274	{
3275	ring r=(ring)v->Data();
3276	int elems=-1;
3277	if (rField_is_Zp(r)\|\|rField_is_GF(r)) elems=rInternalChar(r);
3278	else if (rField_is_Zp_a(r) && (r->minpoly!=NULL))
3279	{
3280	#ifdef HAVE_FACTORY
3281	extern int ipower ( int b, int n ); /* factory/cf_util */
3282	elems=ipower(ABS(rInternalChar(r)),naParDeg(r->minpoly));
3283	#else
3284	elems=(int)pow(ABS((double) rInternalChar(r)),(double)naParDeg(r->minpoly));
3285	#endif
3286	}
3287	res->data = (char *)elems;
3288	return FALSE;
3289	}
3290	static BOOLEAN jjDEG(leftv res, leftv v)
3291	{
3292	int dummy;
3293	poly p=(poly)v->Data();
3294	if (p!=NULL) res->data = (char *)pLDeg(p,&dummy,currRing);
3295	else res->data=(char *)-1;
3296	return FALSE;
3297	}
3298	static BOOLEAN jjDEG_M(leftv res, leftv u)
3299	{
3300	ideal I=(ideal)u->Data();
3301	int d=-1;
3302	int dummy;
3303	int i;
3304	for(i=IDELEMS(I)-1;i>=0;i--)
3305	if (I->m[i]!=NULL) d=si_max(d,(int)pLDeg(I->m[i],&dummy,currRing));
3306	res->data = (char *)d;
3307	return FALSE;
3308	}
3309	static BOOLEAN jjDEGREE(leftv res, leftv v)
3310	{
3311	assumeStdFlag(v);
3312	intvec module_w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3313	scDegree((ideal)v->Data(),module_w,currQuotient);
3314	return FALSE;
3315	}
3316	static BOOLEAN jjDEFINED(leftv res, leftv v)
3317	{
3318	if ((v->rtyp==IDHDL)
3319	&& ((myynest==IDLEV((idhdl)v->data))\|\|(0==IDLEV((idhdl)v->data))))
3320	{
3321	res->data=(void *)(IDLEV((idhdl)v->data)+1);
3322	}
3323	else if (v->rtyp!=0) res->data=(void *)(-1);
3324	return FALSE;
3325	}
3326	#ifdef HAVE_FACTORY
3327	static BOOLEAN jjDET(leftv res, leftv v)
3328	{
3329	matrix m=(matrix)v->Data();
3330	poly p;
3331	if (smCheckDet((ideal)m,m->cols(),TRUE))
3332	{
3333	ideal I=idMatrix2Module(mpCopy(m));
3334	p=smCallDet(I);
3335	idDelete(&I);
3336	}
3337	else
3338	p=singclap_det(m);
3339	res ->data = (char *)p;
3340	return FALSE;
3341	}
3342	static BOOLEAN jjDET_I(leftv res, leftv v)
3343	{
3344	intvec * m=(intvec*)v->Data();
3345	int i,j;
3346	i=m->rows();j=m->cols();
3347	if(i==j)
3348	res->data = (char *)singclap_det_i(m);
3349	else
3350	{
3351	Werror("det of %d x %d intmat",i,j);
3352	return TRUE;
3353	}
3354	return FALSE;
3355	}
3356	static BOOLEAN jjDET_S(leftv res, leftv v)
3357	{
3358	ideal I=(ideal)v->Data();
3359	poly p;
3360	if (smCheckDet(I,IDELEMS(I),FALSE))
3361	{
3362	matrix m=idModule2Matrix(idCopy(I));
3363	p=singclap_det(m);
3364	idDelete((ideal *)&m);
3365	}
3366	else
3367	p=smCallDet(I);
3368	res->data = (char *)p;
3369	return FALSE;
3370	}
3371	#endif
3372	static BOOLEAN jjDIM(leftv res, leftv v)
3373	{
3374	assumeStdFlag(v);
3375	res->data = (char *)scDimInt((ideal)(v->Data()),currQuotient);
3376	return FALSE;
3377	}
3378	static BOOLEAN jjDUMP(leftv res, leftv v)
3379	{
3380	si_link l = (si_link)v->Data();
3381	if (slDump(l))
3382	{
3383	const char *s;
3384	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3385	else s=sNoName;
3386	Werror("cannot dump to `%s`",s);
3387	return TRUE;
3388	}
3389	else
3390	return FALSE;
3391	}
3392	static BOOLEAN jjE(leftv res, leftv v)
3393	{
3394	res->data = (char *)pOne();
3395	pSetComp((poly)res->data,(int)(long)v->Data());
3396	pSetm((poly)res->data);
3397	return FALSE;
3398	}
3399	static BOOLEAN jjEXECUTE(leftv res, leftv v)
3400	{
3401	char * d = (char *)v->Data();
3402	char * s = (char *)omAlloc(strlen(d) + 13);
3403	strcpy( s, (char *)d);
3404	strcat( s, "\n;RETURN();\n");
3405	newBuffer(s,BT_execute);
3406	return yyparse();
3407	}
3408	#ifdef HAVE_FACTORY
3409	static BOOLEAN jjFACSTD(leftv res, leftv v)
3410	{
3411	ideal_list p,h;
3412	h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
3413	p=h;
3414	int l=0;
3415	while (p!=NULL) { p=p->next;l++; }
3416	lists L=(lists)omAllocBin(slists_bin);
3417	L->Init(l);
3418	l=0;
3419	while(h!=NULL)
3420	{
3421	L->m[l].data=(char *)h->d;
3422	L->m[l].rtyp=IDEAL_CMD;
3423	p=h->next;
3424	omFreeSize(h,sizeof(*h));
3425	h=p;
3426	l++;
3427	}
3428	res->data=(void *)L;
3429	return FALSE;
3430	}
3431	static BOOLEAN jjFAC_P(leftv res, leftv u)
3432	{
3433	intvec *v=NULL;
3434	singclap_factorize_retry=0;
3435	ideal f=singclap_factorize((poly)(u->Data()), &v, 0);
3436	if (f==NULL) return TRUE;
3437	ivTest(v);
3438	lists l=(lists)omAllocBin(slists_bin);
3439	l->Init(2);
3440	l->m[0].rtyp=IDEAL_CMD;
3441	l->m[0].data=(void *)f;
3442	l->m[1].rtyp=INTVEC_CMD;
3443	l->m[1].data=(void *)v;
3444	res->data=(void *)l;
3445	return FALSE;
3446	}
3447	#endif
3448	static BOOLEAN jjGETDUMP(leftv res, leftv v)
3449	{
3450	si_link l = (si_link)v->Data();
3451	if (slGetDump(l))
3452	{
3453	const char *s;
3454	if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3455	else s=sNoName;
3456	Werror("cannot get dump from `%s`",s);
3457	return TRUE;
3458	}
3459	else
3460	return FALSE;
3461	}
3462	static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
3463	{
3464	assumeStdFlag(v);
3465	ideal I=(ideal)v->Data();
3466	res->data=(void *)iiHighCorner(I,0);
3467	return FALSE;
3468	}
3469	static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
3470	{
3471	assumeStdFlag(v);
3472	intvec w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3473	BOOLEAN delete_w=FALSE;
3474	ideal I=(ideal)v->Data();
3475	int i;
3476	poly p=NULL,po=NULL;
3477	int rk=idRankFreeModule(I);
3478	if (w==NULL)
3479	{
3480	w = new intvec(rk);
3481	delete_w=TRUE;
3482	}
3483	for(i=rk;i>0;i--)
3484	{
3485	p=iiHighCorner(I,i);
3486	if (p==NULL)
3487	{
3488	WerrorS("module must be zero-dimensional");
3489	if (delete_w) delete w;
3490	return TRUE;
3491	}
3492	if (po==NULL)
3493	{
3494	po=p;
3495	}
3496	else
3497	{
3498	// now po!=NULL, p!=NULL
3499	int d=(pFDeg(po,currRing)-(w)[pGetComp(po)-1] - pFDeg(p,currRing)+(w)[i-1]);
3500	if (d==0)
3501	d=pLmCmp(po,p);
3502	if (d > 0)
3503	{
3504	pDelete(&p);
3505	}
3506	else // (d < 0)
3507	{
3508	pDelete(&po); po=p;
3509	}
3510	}
3511	}
3512	if (delete_w) delete w;
3513	res->data=(void *)po;
3514	return FALSE;
3515	}
3516	static BOOLEAN jjHILBERT(leftv res, leftv v)
3517	{
3518	assumeStdFlag(v);
3519	intvec module_w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3520	//scHilbertPoly((ideal)v->Data(),currQuotient);
3521	hLookSeries((ideal)v->Data(),module_w,currQuotient);
3522	return FALSE;
3523	}
3524	static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
3525	{
3526	res->data=(void )hSecondSeries((intvec )v->Data());
3527	return FALSE;
3528	}
3529	static BOOLEAN jjHOMOG1(leftv res, leftv v)
3530	{
3531	intvec w=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3532	ideal v_id=(ideal)v->Data();
3533	if (w==NULL)
3534	{
3535	res->data=(void *)idHomModule(v_id,currQuotient,&w);
3536	if ((res->data!=NULL) && (v->rtyp==IDHDL))
3537	{
3538	char *isHomog=omStrDup("isHomog");
3539	if (v->e==NULL)
3540	atSet((idhdl)(v->data),isHomog,w,INTVEC_CMD);
3541	else
3542	atSet((idhdl)(v->LData()),isHomog,w,INTVEC_CMD);
3543	}
3544	else if (w!=NULL) delete w;
3545	}
3546	else
3547	res->data=(void *)idTestHomModule(v_id,currQuotient,w);
3548	return FALSE;
3549	}
3550	static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
3551	{
3552	matrix mat=(matrix)v->CopyD(MATRIX_CMD);
3553	IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
3554	if (IDELEMS((ideal)mat)==0)
3555	{
3556	idDelete((ideal *)&mat);
3557	mat=(matrix)idInit(1,1);
3558	}
3559	else
3560	{
3561	MATROWS(mat)=1;
3562	mat->rank=1;
3563	idTest((ideal)mat);
3564	}
3565	res->data=(char *)mat;
3566	return FALSE;
3567	}
3568	static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
3569	{
3570	map m=(map)v->CopyD(MAP_CMD);
3571	omFree((ADDRESS)m->preimage);
3572	m->preimage=NULL;
3573	ideal I=(ideal)m;
3574	I->rank=1;
3575	res->data=(char *)I;
3576	return FALSE;
3577	}
3578	static BOOLEAN jjIDEAL_R(leftv res, leftv v)
3579	{
3580	if (currRing!=NULL)
3581	{
3582	ring q=(ring)v->Data();
3583	if (rEqual(currRing, q, 0))
3584	{
3585	if (q->qideal==NULL)
3586	res->data=(char *)idInit(1,1);
3587	else
3588	res->data=(char *)idCopy(q->qideal);
3589	return FALSE;
3590	}
3591	}
3592	WerrorS("can only get ideal from identical qring");
3593	return TRUE;
3594	}
3595	static BOOLEAN jjIm2Iv(leftv res, leftv v)
3596	{
3597	intvec iv = (intvec )v->CopyD(INTMAT_CMD);
3598	iv->makeVector();
3599	res->data = iv;
3600	return FALSE;
3601	}
3602	static BOOLEAN jjIMPART(leftv res, leftv v)
3603	{
3604	res->data = (char *)nImPart((number)v->Data());
3605	return FALSE;
3606	}
3607	static BOOLEAN jjINDEPSET(leftv res, leftv v)
3608	{
3609	assumeStdFlag(v);
3610	res->data=(void *)scIndIntvec((ideal)(v->Data()),currQuotient);
3611	return FALSE;
3612	}
3613	static BOOLEAN jjINTERRED(leftv res, leftv v)
3614	{
3615	ideal result=kInterRed((ideal)(v->Data()),currQuotient);
3616	//if (result==NULL) return TRUE;
3617	res->data = result;
3618	return FALSE;
3619	}
3620	static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
3621	{
3622	res->data = (char *)pVar((poly)v->Data());
3623	return FALSE;
3624	}
3625	static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
3626	{
3627	res->data = (char )(r_IsRingVar((char )v->Data(), currRing)+1);
3628	return FALSE;
3629	}
3630	static BOOLEAN jjIS_RINGVAR0(leftv res, leftv v)
3631	{
3632	res->data = (char *)0;
3633	return FALSE;
3634	}
3635	static BOOLEAN jjJACOB_P(leftv res, leftv v)
3636	{
3637	ideal i=idInit(pVariables,1);
3638	int k;
3639	poly p=(poly)(v->Data());
3640	for (k=pVariables;k>0;k--)
3641	{
3642	i->m[k-1]=pDiff(p,k);
3643	}
3644	res->data = (char *)i;
3645	return FALSE;
3646	}
3647	static BOOLEAN jjKBASE(leftv res, leftv v)
3648	{
3649	assumeStdFlag(v);
3650	res->data = (char *)scKBase(-1,(ideal)(v->Data()),currQuotient);
3651	return FALSE;
3652	}
3653	#ifdef MDEBUG
3654	static BOOLEAN jjpHead(leftv res, leftv v)
3655	{
3656	res->data=(char *)pHead((poly)v->Data());
3657	return FALSE;
3658	}
3659	#endif
3660	static BOOLEAN jjL2R(leftv res, leftv v)
3661	{
3662	res->data=(char *)syConvList((lists)v->Data());
3663	if (res->data != NULL)
3664	return FALSE;
3665	else
3666	return TRUE;
3667	}
3668	static BOOLEAN jjLEADCOEF(leftv res, leftv v)
3669	{
3670	poly p=(poly)v->Data();
3671	if (p==NULL)
3672	{
3673	res->data=(char *)nInit(0);
3674	}
3675	else
3676	{
3677	res->data=(char *)nCopy(pGetCoeff(p));
3678	}
3679	return FALSE;
3680	}
3681	static BOOLEAN jjLEADEXP(leftv res, leftv v)
3682	{
3683	poly p=(poly)v->Data();
3684	int s=pVariables;
3685	if (v->Typ()==VECTOR_CMD) s++;
3686	intvec *iv=new intvec(s);
3687	if (p!=NULL)
3688	{
3689	for(int i = pVariables;i;i--)
3690	{
3691	(*iv)[i-1]=pGetExp(p,i);
3692	}
3693	if (s!=pVariables)
3694	(*iv)[pVariables]=pGetComp(p);
3695	}
3696	res->data=(char *)iv;
3697	return FALSE;
3698	}
3699	static BOOLEAN jjLEADMONOM(leftv res, leftv v)
3700	{
3701	poly p=(poly)v->Data();
3702	if (p == NULL)
3703	{
3704	res->data = (char*) NULL;
3705	}
3706	else
3707	{
3708	poly lm = pLmInit(p);
3709	pSetCoeff(lm, nInit(1));
3710	res->data = (char*) lm;
3711	}
3712	return FALSE;
3713	}
3714	static BOOLEAN jjLISTRING(leftv res, leftv v)
3715	{
3716	ring r=rCompose((lists)v->Data());
3717	if (r==NULL) return TRUE;
3718	if (r->qideal!=NULL) res->rtyp=QRING_CMD;
3719	res->data=(char *)r;
3720	return FALSE;
3721	}
3722	#if SIZEOF_LONG == 8
3723	static number jjBI2N(long d);
3724	#else
3725	#define jjBI2N(D) nlInit((int)D)
3726	#endif
3727	static BOOLEAN jjMEMORY(leftv res, leftv v)
3728	{
3729	omUpdateInfo();
3730	long d;
3731	switch(((int)(long)v->Data()))
3732	{
3733	case 0:
3734	res->data=(char *)jjBI2N(om_Info.UsedBytes);
3735	break;
3736	case 1:
3737	res->data = (char *)jjBI2N(om_Info.CurrentBytesSystem);
3738	break;
3739	case 2:
3740	res->data = (char *)jjBI2N(om_Info.MaxBytesSystem);
3741	break;
3742
3743	default:
3744	omPrintStats(stdout);
3745	omPrintInfo(stdout);
3746	omPrintBinStats(stdout);
3747	res->data = (char *)0;
3748	res->rtyp = NONE;
3749	}
3750	return FALSE;
3751	res->data = (char *)0;
3752	return FALSE;
3753	}
3754	#if SIZEOF_LONG == 8
3755	static number jjBI2N(long d)
3756	{
3757	if (d<((long)INT_MAX)) return nlInit((int)d);
3758	else
3759	{
3760	number n=nlRInit(0);
3761	mpz_set_si(&n->z,d);
3762	return n;
3763	}
3764	}
3765	#endif
3766	static BOOLEAN jjMONITOR1(leftv res, leftv v)
3767	{
3768	monitor((char *)(v->Data()),PROT_I);
3769	return FALSE;
3770	}
3771	static BOOLEAN jjMSTD(leftv res, leftv v)
3772	{
3773	int t=v->Typ();
3774	ideal r,m;
3775	r=kMin_std((ideal)v->Data(),currQuotient,testHomog,NULL,m);
3776	lists l=(lists)omAllocBin(slists_bin);
3777	l->Init(2);
3778	l->m[0].rtyp=t;
3779	l->m[0].data=(char *)r;
3780	setFlag(&(l->m[0]),FLAG_STD);
3781	l->m[1].rtyp=t;
3782	l->m[1].data=(char *)m;
3783	res->data=(char *)l;
3784	return FALSE;
3785	}
3786	static BOOLEAN jjMULT(leftv res, leftv v)
3787	{
3788	assumeStdFlag(v);
3789	res->data = (char *)scMultInt((ideal)(v->Data()),currQuotient);
3790	return FALSE;
3791	}
3792	static BOOLEAN jjMINRES_R(leftv res, leftv v)
3793	{
3794	intvec weights=(intvec)atGet(v,"isHomog",INTVEC_CMD);
3795	res->data=(char *)syMinimize((syStrategy)v->Data());
3796	if (weights!=NULL)
3797	atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
3798	return FALSE;
3799	}
3800	static BOOLEAN jjN2BI(leftv res, leftv v)
3801	{
3802	number n,i; i=(number)v->Data();
3803	if (rField_is_Zp()) n=nlInit((int)(long)i);
3804	else if (rField_is_Q())
3805	{
3806	if ((SR_HDL(i)&SR_INT)==SR_INT) n=nlInit((int)SR_TO_INT(i));
3807	else if (i->s==3) n=nlCopy(i);
3808	else goto err;
3809	}
3810	else goto err;
3811	res->data=(void *)n;
3812	return FALSE;
3813	err:
3814	WerrorS("cannot convert to bigint"); return TRUE;
3815	}
3816	static BOOLEAN jjNAMEOF(leftv res, leftv v)
3817	{
3818	res->data = (char *)v->name;
3819	if (res->data==NULL) res->data=omStrDup("");
3820	v->name=NULL;
3821	return FALSE;
3822	}
3823	static BOOLEAN jjNAMES(leftv res, leftv v)
3824	{
3825	res->data=ipNameList(((ring)v->Data())->idroot);
3826	return FALSE;
3827	}
3828	static BOOLEAN jjNVARS(leftv res, leftv v)
3829	{
3830	res->data = (char *)(((ring)(v->Data()))->N);
3831	return FALSE;
3832	}
3833	static BOOLEAN jjOpenClose(leftv res, leftv v)
3834	{
3835	si_link l=(si_link)v->Data();
3836	if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN);
3837	else return slClose(l);
3838	}
3839	static BOOLEAN jjORD(leftv res, leftv v)
3840	{
3841	poly p=(poly)v->Data();
3842	res->data=(char *)( p==NULL ? -1 : pFDeg(p,currRing) );
3843	return FALSE;
3844	}
3845	static BOOLEAN jjPAR1(leftv res, leftv v)
3846	{
3847	int i=(int)(long)v->Data();
3848	int p=0;
3849	p=rPar(currRing);
3850	if ((0<i) && (i<=p))
3851	{
3852	res->data=(char *)nPar(i);
3853	}
3854	else
3855	{
3856	Werror("par number %d out of range 1..%d",i,p);
3857	return TRUE;
3858	}
3859	return FALSE;
3860	}
3861	static BOOLEAN jjPARDEG(leftv res, leftv v)
3862	{
3863	res->data = (char *)nParDeg((number)v->Data());
3864	return FALSE;
3865	}
3866	static BOOLEAN jjPARSTR1(leftv res, leftv v)
3867	{
3868	if (currRing==NULL)
3869	{
3870	WerrorS("no ring active");
3871	return TRUE;
3872	}
3873	int i=(int)(long)v->Data();
3874	int p=0;
3875	if ((0<i) && (currRing->parameter!=NULL) && (i<=(p=rPar(currRing))))
3876	res->data=omStrDup(currRing->parameter[i-1]);
3877	else
3878	{
3879	Werror("par number %d out of range 1..%d",i,p);
3880	return TRUE;
3881	}
3882	return FALSE;
3883	}
3884	static BOOLEAN jjP2I(leftv res, leftv v)
3885	{
3886	poly p=(poly)v->Data();
3887	if (p==NULL) { /res->data=(char )0;*/ return FALSE; }
3888	if ((pNext(p)!=NULL)\|\| (!pIsConstant(p)))
3889	{
3890	WerrorS("poly must be constant");
3891	return TRUE;
3892	}
3893	res->data = (char *)nInt(pGetCoeff(p));
3894	return FALSE;
3895	}
3896	static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
3897	{
3898	map mapping=(map)v->Data();
3899	syMake(res,omStrDup(mapping->preimage));
3900	return FALSE;
3901	}
3902	static BOOLEAN jjPRIME(leftv res, leftv v)
3903	{
3904	int i = IsPrime((int)(long)(v->Data()));
3905	res->data = (char *)(i > 1 ? i : 2);
3906	return FALSE;
3907	}
3908	static BOOLEAN jjPRUNE(leftv res, leftv v)
3909	{
3910	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
3911	ideal v_id=(ideal)v->Data();
3912	if (w!=NULL)
3913	{
3914	if (!idTestHomModule(v_id,currQuotient,w))
3915	{
3916	WarnS("wrong weights");
3917	w=NULL;
3918	// and continue at the non-homog case below
3919	}
3920	else
3921	{
3922	w=ivCopy(w);
3923	intvec **ww=&w;
3924	res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
3925	atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
3926	return FALSE;
3927	}
3928	}
3929	res->data = (char *)idMinEmbedding(v_id);
3930	return FALSE;
3931	}
3932	static BOOLEAN jjP2N(leftv res, leftv v)
3933	{
3934	number n;
3935	poly p;
3936	if (((p=(poly)v->Data())!=NULL)
3937	&& (pIsConstant(p)))
3938	{
3939	n=nCopy(pGetCoeff(p));
3940	}
3941	else
3942	{
3943	n=nInit(0);
3944	}
3945	res->data = (char *)n;
3946	return FALSE;
3947	}
3948	static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
3949	{
3950	char s= (char )v->Data();
3951	int i = 1;
3952	int l = strlen(s);
3953	while (cmds[i].tokval!=0)
3954	{
3955	if (strcmp(s, cmds[i].name) == 0)
3956	{
3957	res->data = (char *)1;
3958	return FALSE;
3959	}
3960	i++;
3961	}
3962	//res->data = (char *)0;
3963	return FALSE;
3964	}
3965	static BOOLEAN jjREAD(leftv res, leftv v)
3966	{
3967	return jjREAD2(res,v,NULL);
3968	}
3969	static BOOLEAN jjREGULARITY(leftv res, leftv v)
3970	{
3971	res->data = (char *)iiRegularity((lists)v->Data());
3972	return FALSE;
3973	}
3974	static BOOLEAN jjREPART(leftv res, leftv v)
3975	{
3976	res->data = (char *)nRePart((number)v->Data());
3977	return FALSE;
3978	}
3979	static BOOLEAN jjRINGLIST(leftv res, leftv v)
3980	{
3981	ring r=(ring)v->Data();
3982	if (r!=NULL)
3983	res->data = (char *)rDecompose((ring)v->Data());
3984	return (r==NULL)\|\|(res->data==NULL);
3985	}
3986	static BOOLEAN jjROWS(leftv res, leftv v)
3987	{
3988	ideal i = (ideal)v->Data();
3989	res->data = (char *)i->rank;
3990	return FALSE;
3991	}
3992	static BOOLEAN jjROWS_IV(leftv res, leftv v)
3993	{
3994	res->data = (char )((intvec)(v->Data()))->rows();
3995	return FALSE;
3996	}
3997	static BOOLEAN jjRPAR(leftv res, leftv v)
3998	{
3999	res->data = (char *)rPar(((ring)v->Data()));
4000	return FALSE;
4001	}
4002	static BOOLEAN jjSLIM_GB(leftv res, leftv u)
4003	{
4004	if (currQuotient!=NULL)
4005	{
4006	Werror("qring not supported by slimgb at the moment");
4007	return TRUE;
4008	}
4009	if (pOrdSgn!=1)
4010	{
4011	Werror("ordering must be global for slimgb");
4012	return TRUE;
4013	}
4014	intvec w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
4015	tHomog hom=testHomog;
4016	ideal u_id=(ideal)u->Data();
4017	if (w!=NULL)
4018	{
4019	if (!idTestHomModule(u_id,currQuotient,w))
4020	{
4021	WarnS("wrong weights");
4022	w=NULL;
4023	}
4024	else
4025	{
4026	w=ivCopy(w);
4027	hom=isHomog;
4028	}
4029	}
4030
4031	assume(u_id->rank>=idRankFreeModule(u_id));
4032	res->data=(char *)t_rep_gb(currRing,
4033	u_id,u_id->rank);
4034	//res->data=(char *)t_rep_gb(currRing, u_id);
4035
4036	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4037	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4038	return FALSE;
4039	}
4040	static BOOLEAN jjSTD(leftv res, leftv v)
4041	{
4042	ideal result;
4043	ideal v_id=(ideal)v->Data();
4044	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4045	tHomog hom=testHomog;
4046	if (w!=NULL)
4047	{
4048	if (!idTestHomModule(v_id,currQuotient,w))
4049	{
4050	WarnS("wrong weights");
4051	w=NULL;
4052	}
4053	else
4054	{
4055	hom=isHomog;
4056	w=ivCopy(w);
4057	}
4058	}
4059	result=kStd(v_id,currQuotient,hom,&w);
4060	idSkipZeroes(result);
4061	res->data = (char *)result;
4062	if(!TEST_OPT_DEGBOUND) setFlag(res,FLAG_STD);
4063	if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4064	return FALSE;
4065	}
4066	static BOOLEAN jjSort_Id(leftv res, leftv v)
4067	{
4068	res->data = (char *)idSort((ideal)v->Data());
4069	return FALSE;
4070	}
4071	#if 1
4072	static BOOLEAN jjSYZYGY(leftv res, leftv v)
4073	{
4074	intvec *w=NULL;
4075	res->data = (char *)idSyzygies((ideal)v->Data(),testHomog,&w);
4076	if (w!=NULL) delete w;
4077	return FALSE;
4078	}
4079	#else
4080	// activate, if idSyz hadle moduke weights correctly !
4081	static BOOLEAN jjSYZYGY(leftv res, leftv v)
4082	{
4083	intvec w=(intvec )atGet(v,"isHomog",INTVEC_CMD);
4084	ideal v_id=(ideal)v->Data();
4085	tHomog hom=testHomog;
4086	int add_row_shift=0;
4087	if (w!=NULL)
4088	{
4089	w=ivCopy(w);
4090	add_row_shift=w->min_in();
4091	(*w)-=add_row_shift;
4092	if (idTestHomModule(v_id,currQuotient,w))
4093	hom=isHomog;
4094	else
4095	{
4096	//WarnS("wrong weights");
4097	delete w; w=NULL;
4098	hom=testHomog;
4099	}
4100	}
4101	res->data = (char *)idSyzygies(v_id,hom,&w);
4102	if (w!=NULL)
4103	{
4104	atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4105	}
4106	return FALSE;
4107	}
4108	#endif
4109	static BOOLEAN jjTRACE_IV(leftv res, leftv v)
4110	{
4111	res->data = (char )ivTrace((intvec)(v->Data()));
4112	return FALSE;
4113	}
4114	static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
4115	{
4116	res->data = (char )ivTranp((intvec)(v->Data()));
4117	return FALSE;
4118	}
4119
4120	#ifdef HAVE_PLURAL
4121
4122	static BOOLEAN jjOPPOSITE(leftv res, leftv a)
4123	{
4124	ring r = (ring)a->Data();
4125	if (rIsPluralRing(r))
4126	{
4127	res->data = rOpposite(r);
4128	}
4129	else res->data = rCopy(r);
4130	return FALSE;
4131	}
4132
4133	static BOOLEAN jjENVELOPE(leftv res, leftv a)
4134	{
4135	ring r = (ring)a->Data();
4136	if (rIsPluralRing(r))
4137	{
4138	// ideal i;
4139	// if (a->rtyp == QRING_CMD)
4140	// {
4141	// i = r->qideal;
4142	// r->qideal = NULL;
4143	// }
4144	ring s = rEnvelope(r);
4145	// if (a->rtyp == QRING_CMD)
4146	// {
4147	// ideal is = idOppose(r,i); /* twostd? */
4148	// is = idAdd(is,i);
4149	// s->qideal = i;
4150	// }
4151	res->data = s;
4152	}
4153	else res->data = rCopy(r);
4154	return FALSE;
4155	}
4156
4157	static BOOLEAN jjTWOSTD(leftv res, leftv a)
4158	{
4159	if (rIsPluralRing(currRing)) res->data=(ideal)twostd((ideal)a->Data());
4160	else res->data=(ideal)a->Data();
4161	setFlag(res,FLAG_STD);
4162	setFlag(res,FLAG_TWOSTD);
4163	return FALSE;
4164	}
4165	#endif
4166
4167	static BOOLEAN jjTYPEOF(leftv res, leftv v)
4168	{
4169	switch ((int)(long)v->data)
4170	{
4171	case INT_CMD: res->data=omStrDup("int"); break;
4172	case POLY_CMD: res->data=omStrDup("poly"); break;
4173	case VECTOR_CMD: res->data=omStrDup("vector"); break;
4174	case STRING_CMD: res->data=omStrDup("string"); break;
4175	case INTVEC_CMD: res->data=omStrDup("intvec"); break;
4176	case IDEAL_CMD: res->data=omStrDup("ideal"); break;
4177	case MATRIX_CMD: res->data=omStrDup("matrix"); break;
4178	case MODUL_CMD: res->data=omStrDup("module"); break;
4179	case MAP_CMD: res->data=omStrDup("map"); break;
4180	case PROC_CMD: res->data=omStrDup("proc"); break;
4181	case RING_CMD: res->data=omStrDup("ring"); break;
4182	case QRING_CMD: res->data=omStrDup("qring"); break;
4183	case INTMAT_CMD: res->data=omStrDup("intmat"); break;
4184	case NUMBER_CMD: res->data=omStrDup("number"); break;
4185	case BIGINT_CMD: res->data=omStrDup("bigint"); break;
4186	case LIST_CMD: res->data=omStrDup("list"); break;
4187	case PACKAGE_CMD: res->data=omStrDup("package"); break;
4188	case LINK_CMD: res->data=omStrDup("link"); break;
4189	case RESOLUTION_CMD:res->data=omStrDup("resolution");break;
4190	case DEF_CMD:
4191	case NONE: res->data=omStrDup("none"); break;
4192	default: res->data=omStrDup("?unknown type?");
4193	}
4194	return FALSE;
4195	}
4196	static BOOLEAN jjVAR1(leftv res, leftv v)
4197	{
4198	int i=(int)(long)v->Data();
4199	if ((0<i) && (i<=currRing->N))
4200	{
4201	poly p=pOne();
4202	pSetExp(p,i,1);
4203	pSetm(p);
4204	res->data=(char *)p;
4205	}
4206	else
4207	{
4208	Werror("var number %d out of range 1..%d",i,currRing->N);
4209	return TRUE;
4210	}
4211	return FALSE;
4212	}
4213	static BOOLEAN jjVARSTR1(leftv res, leftv v)
4214	{
4215	if (currRing==NULL)
4216	{
4217	WerrorS("no ring active");
4218	return TRUE;
4219	}
4220	int i=(int)(long)v->Data();
4221	if ((0<i) && (i<=currRing->N))
4222	res->data=omStrDup(currRing->names[i-1]);
4223	else
4224	{
4225	Werror("var number %d out of range 1..%d",i,currRing->N);
4226	return TRUE;
4227	}
4228	return FALSE;
4229	}
4230	static BOOLEAN jjVDIM(leftv res, leftv v)
4231	{
4232	assumeStdFlag(v);
4233	res->data = (char *)scMult0Int((ideal)v->Data(),currQuotient);
4234	return FALSE;
4235	}
4236
4237	static BOOLEAN jjLOAD1(leftv res, leftv v)
4238	{
4239	return jjLOAD(res, v,iiOp==LIB_CMD);
4240	}
4241	static BOOLEAN jjLOAD(leftv res, leftv v, BOOLEAN autoexport)
4242	{
4243	#ifdef HAVE_NS
4244	char * s=(char *)v->CopyD();
4245	char libnamebuf[256];
4246	lib_types LT = type_of_LIB(s, libnamebuf);
4247	#ifdef HAVE_DYNAMIC_LOADING
4248	extern BOOLEAN load_modules(char newlib, char fullpath, BOOLEAN autoexport);
4249	#endif /* HAVE_DYNAMIC_LOADING */
4250	switch(LT)
4251	{
4252	default:
4253	case LT_NONE:
4254	Werror("%s: unknown type", s);
4255	break;
4256	case LT_NOTFOUND:
4257	Werror("cannot open %s", s);
4258	break;
4259
4260	case LT_SINGULAR:
4261	{
4262	char *plib = iiConvName(s);
4263	idhdl pl = IDROOT->get(plib,0);
4264	if (pl==NULL)
4265	{
4266	pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
4267	IDPACKAGE(pl)->language = LANG_SINGULAR;
4268	IDPACKAGE(pl)->libname=omStrDup(plib);
4269	}
4270	else if (IDTYP(pl)!=PACKAGE_CMD)
4271	{
4272	Werror("can not create package `%s`",plib);
4273	omFree(plib);
4274	return TRUE;
4275	}
4276	package savepack=currPack;
4277	currPack=IDPACKAGE(pl);
4278	IDPACKAGE(pl)->loaded=TRUE;
4279	char libnamebuf[256];
4280	FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
4281	BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
4282	currPack=savepack;
4283	IDPACKAGE(pl)->loaded=(!bo);
4284	return bo;
4285	}
4286	case LT_MACH_O:
4287	case LT_ELF:
4288	case LT_HPUX:
4289	#ifdef HAVE_DYNAMIC_LOADING
4290	return load_modules(s, libnamebuf, autoexport);
4291	#else /* HAVE_DYNAMIC_LOADING */
4292	WerrorS("Dynamic modules are not supported by this version of Singular");
4293	break;
4294	#endif /* HAVE_DYNAMIC_LOADING */
4295	}
4296	#endif
4297	return TRUE;
4298	}
4299
4300	/=================== operations with 1 arg.: table =================/
4301
4302	#ifdef INIT_BUG
4303	#define XS(A) -((short)A)
4304	#define jjstrlen (proc1)1
4305	#define jjpLength (proc1)2
4306	#define jjidElem (proc1)3
4307	#define jjmpDetBareiss (proc1)4
4308	#define jjidFreeModule (proc1)5
4309	#define jjidVec2Ideal (proc1)6
4310	#define jjrCharStr (proc1)7
4311	#ifndef MDEBUG
4312	#define jjpHead (proc1)8
4313	#endif
4314	#define jjidHead (proc1)9
4315	#define jjidMaxIdeal (proc1)10
4316	#define jjidMinBase (proc1)11
4317	#define jjsyMinBase (proc1)12
4318	#define jjpMaxComp (proc1)13
4319	#define jjmpTrace (proc1)14
4320	#define jjmpTransp (proc1)15
4321	#define jjrOrdStr (proc1)16
4322	#define jjrVarStr (proc1)18
4323	#define jjrParStr (proc1)19
4324	#define jjCOUNT_RES (proc1)22
4325	#define jjDIM_R (proc1)23
4326	#define jjidTransp (proc1)24
4327
4328	extern struct sValCmd1 dArith1[];
4329	void jjInitTab1()
4330	{
4331	int i=0;
4332	for (;dArith1[i].cmd!=0;i++)
4333	{
4334	if (dArith1[i].res<0)
4335	{
4336	switch ((int)dArith1[i].p)
4337	{
4338	case (int)jjstrlen: dArith1[i].p=(proc1)strlen; break;
4339	case (int)jjpLength: dArith1[i].p=(proc1)pLength; break;
4340	case (int)jjidElem: dArith1[i].p=(proc1)idElem; break;
4341	case (int)jjidVec2Ideal: dArith1[i].p=(proc1)idVec2Ideal; break;
4342	#ifndef HAVE_FACTORY
4343	case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
4344	#endif
4345	case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
4346	case (int)jjrCharStr: dArith1[i].p=(proc1)rCharStr; break;
4347	#ifndef MDEBUG
4348	case (int)jjpHead: dArith1[i].p=(proc1)pHeadProc; break;
4349	#endif
4350	case (int)jjidHead: dArith1[i].p=(proc1)idHead; break;
4351	case (int)jjidMaxIdeal: dArith1[i].p=(proc1)idMaxIdeal; break;
4352	case (int)jjidMinBase: dArith1[i].p=(proc1)idMinBase; break;
4353	case (int)jjsyMinBase: dArith1[i].p=(proc1)syMinBase; break;
4354	case (int)jjpMaxComp: dArith1[i].p=(proc1)pMaxCompProc; break;
4355	case (int)jjmpTrace: dArith1[i].p=(proc1)mpTrace; break;
4356	case (int)jjmpTransp: dArith1[i].p=(proc1)mpTransp; break;
4357	case (int)jjrOrdStr: dArith1[i].p=(proc1)rOrdStr; break;
4358	case (int)jjrVarStr: dArith1[i].p=(proc1)rVarStr; break;
4359	case (int)jjrParStr: dArith1[i].p=(proc1)rParStr; break;
4360	case (int)jjCOUNT_RES: dArith1[i].p=(proc1)syLength; break;
4361	case (int)jjDIM_R: dArith1[i].p=(proc1)syDim; break;
4362	case (int)jjidTransp: dArith1[i].p=(proc1)idTransp; break;
4363	#ifdef GENTABLE
4364	default: Werror("missing proc1-definition for %d",(int)(long)dArith1[i].p);
4365	#endif
4366	}
4367	}
4368	}
4369	}
4370	#else
4371	#if defined(PROC_BUG)
4372	#define XS(A) A
4373	static BOOLEAN jjstrlen(leftv res, leftv v)
4374	{
4375	res->data = (char )strlen((char )v->Data());
4376	return FALSE;
4377	}
4378	static BOOLEAN jjpLength(leftv res, leftv v)
4379	{
4380	res->data = (char *)pLength((poly)v->Data());
4381	return FALSE;
4382	}
4383	static BOOLEAN jjidElem(leftv res, leftv v)
4384	{
4385	res->data = (char *)idElem((ideal)v->Data());
4386	return FALSE;
4387	}
4388	static BOOLEAN jjmpDetBareiss(leftv res, leftv v)
4389	{
4390	res->data = (char *)mpDetBareiss((matrix)v->Data());
4391	return FALSE;
4392	}
4393	static BOOLEAN jjidFreeModule(leftv res, leftv v)
4394	{
4395	res->data = (char *)idFreeModule((int)(long)v->Data());
4396	return FALSE;
4397	}
4398	static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
4399	{
4400	res->data = (char *)idVec2Ideal((poly)v->Data());
4401	return FALSE;
4402	}
4403	static BOOLEAN jjrCharStr(leftv res, leftv v)
4404	{
4405	res->data = rCharStr((ring)v->Data());
4406	return FALSE;
4407	}
4408	#ifndef MDEBUG
4409	static BOOLEAN jjpHead(leftv res, leftv v)
4410	{
4411	res->data = (char *)pHead((poly)v->Data());
4412	return FALSE;
4413	}
4414	#endif
4415	static BOOLEAN jjidHead(leftv res, leftv v)
4416	{
4417	res->data = (char *)idHead((ideal)v->Data());
4418	return FALSE;
4419	}
4420	static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
4421	{
4422	res->data = (char *)idMaxIdeal((int)(long)v->Data());
4423	return FALSE;
4424	}
4425	static BOOLEAN jjidMinBase(leftv res, leftv v)
4426	{
4427	res->data = (char *)idMinBase((ideal)v->Data());
4428	return FALSE;
4429	}
4430	static BOOLEAN jjsyMinBase(leftv res, leftv v)
4431	{
4432	res->data = (char *)syMinBase((ideal)v->Data());
4433	return FALSE;
4434	}
4435	static BOOLEAN jjpMaxComp(leftv res, leftv v)
4436	{
4437	res->data = (char *)pMaxComp((poly)v->Data());
4438	return FALSE;
4439	}
4440	static BOOLEAN jjmpTrace(leftv res, leftv v)
4441	{
4442	res->data = (char *)mpTrace((matrix)v->Data());
4443	return FALSE;
4444	}
4445	static BOOLEAN jjmpTransp(leftv res, leftv v)
4446	{
4447	res->data = (char *)mpTransp((matrix)v->Data());
4448	return FALSE;
4449	}
4450	static BOOLEAN jjrOrdStr(leftv res, leftv v)
4451	{
4452	res->data = rOrdStr((ring)v->Data());
4453	return FALSE;
4454	}
4455	static BOOLEAN jjrVarStr(leftv res, leftv v)
4456	{
4457	res->data = rVarStr((ring)v->Data());
4458	return FALSE;
4459	}
4460	static BOOLEAN jjrParStr(leftv res, leftv v)
4461	{
4462	res->data = rParStr((ring)v->Data());
4463	return FALSE;
4464	}
4465	static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
4466	{
4467	res->data=(char *)syLength((syStrategy)v->Data());
4468	return FALSE;
4469	}
4470	static BOOLEAN jjDIM_R(leftv res, leftv v)
4471	{
4472	res->data = (char *)syDim((syStrategy)v->Data());
4473	return FALSE;
4474	}
4475	static BOOLEAN jjidTransp(leftv res, leftv v)
4476	{
4477	res->data = (char *)idTransp((ideal)v->Data());
4478	return FALSE;
4479	}
4480	#else
4481	#define XS(A) -((short)A)
4482	#define jjstrlen (proc1)strlen
4483	#define jjpLength (proc1)pLength
4484	#define jjidElem (proc1)idElem
4485	#define jjmpDetBareiss (proc1)mpDetBareiss
4486	#define jjidFreeModule (proc1)idFreeModule
4487	#define jjidVec2Ideal (proc1)idVec2Ideal
4488	#define jjrCharStr (proc1)rCharStr
4489	#ifndef MDEBUG
4490	#define jjpHead (proc1)pHeadProc
4491	#endif
4492	#define jjidHead (proc1)idHead
4493	#define jjidMaxIdeal (proc1)idMaxIdeal
4494	#define jjidMinBase (proc1)idMinBase
4495	#define jjsyMinBase (proc1)syMinBase
4496	#define jjpMaxComp (proc1)pMaxCompProc
4497	#define jjmpTrace (proc1)mpTrace
4498	#define jjmpTransp (proc1)mpTransp
4499	#define jjrOrdStr (proc1)rOrdStr
4500	#define jjrVarStr (proc1)rVarStr
4501	#define jjrParStr (proc1)rParStr
4502	#define jjCOUNT_RES (proc1)syLength
4503	#define jjDIM_R (proc1)syDim
4504	#define jjidTransp (proc1)idTransp
4505	#endif
4506	#endif
4507	static BOOLEAN jjnInt(leftv res, leftv u)
4508	{
4509	number n=(number)u->Data();
4510	res->data=(char *)nInt(n);
4511	return FALSE;
4512	}
4513	static BOOLEAN jjnlInt(leftv res, leftv u)
4514	{
4515	number n=(number)u->Data();
4516	res->data=(char *)nlInt(n);
4517	return FALSE;
4518	}
4519	#define s short
4520	struct sValCmd1 dArith1[]=
4521	{
4522	// operations:
4523	// proc cmd res arg plural
4524	// {jjPLUSPLUS, PLUSPLUS, INT_CMD, INT_CMD ALLOW_PLURAL}
4525	//,{jjMINUSMINUS, MINUSMINUS, INT_CMD, INT_CMD ALLOW_PLURAL}
4526	{jjPLUSPLUS, PLUSPLUS, NONE, IDHDL ALLOW_PLURAL}
4527	,{jjPLUSPLUS, MINUSMINUS, NONE, IDHDL ALLOW_PLURAL}
4528	,{jjUMINUS_I, '-', INT_CMD, INT_CMD ALLOW_PLURAL}
4529	,{jjUMINUS_N, '-', NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4530	,{jjUMINUS_P, '-', POLY_CMD, POLY_CMD ALLOW_PLURAL}
4531	,{jjUMINUS_P, '-', VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4532	,{jjUMINUS_MA, '-', MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
4533	,{jjUMINUS_IV, '-', INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
4534	,{jjUMINUS_IV, '-', INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4535	,{jjPROC1, '(', ANY_TYPE/set by p/,PROC_CMD ALLOW_PLURAL}
4536	,{jjLOAD1, '(', NONE, STRING_CMD ALLOW_PLURAL}
4537	// and the procedures with 1 argument:
4538	,{atATTRIB1, ATTRIB_CMD, NONE, DEF_CMD ALLOW_PLURAL}
4539	//,{jjBAREISS_IM, BAREISS_CMD, INTMAT_CMD, INTMAT_CMD NO_PLURAL}
4540	,{jjBAREISS, BAREISS_CMD, LIST_CMD, MODUL_CMD NO_PLURAL}
4541	,{jjBETTI, BETTI_CMD, INTMAT_CMD, LIST_CMD ALLOW_PLURAL}
4542	,{syBetti1, BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4543	,{jjBETTI, BETTI_CMD, INTMAT_CMD, IDEAL_CMD ALLOW_PLURAL}
4544	,{jjBETTI, BETTI_CMD, INTMAT_CMD, MODUL_CMD ALLOW_PLURAL}
4545	,{jjN2BI, BIGINT_CMD, BIGINT_CMD, NUMBER_CMD ALLOW_PLURAL}
4546	,{jjDUMMY, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD ALLOW_PLURAL}
4547	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4548	,{jjCHAR, CHARACTERISTIC_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4549	#ifdef HAVE_FACTORY
4550	,{jjCHARSERIES, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD NO_PLURAL}
4551	#else
4552	,{jjWRONG, CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD NO_PLURAL}
4553	#endif
4554	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4555	,{jjrCharStr, CHARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4556	,{jjOpenClose, CLOSE_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4557	//,{jjWRONG, COLS_CMD, 0, VECTOR_CMD ALLOW_PLURAL}
4558	,{jjCOLS, COLS_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4559	,{jjCOLS, COLS_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4560	,{jjCOLS, COLS_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4561	,{jjCOLS_IV, COLS_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4562	,{jjWRONG, COLS_CMD, 0, INTVEC_CMD ALLOW_PLURAL}
4563	,{jjCONTENT, CONTENT_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4564	,{jjCONTENT, CONTENT_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4565	,{jjCOUNT_N, COUNT_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4566	,{jjCOUNT_RES, COUNT_CMD, XS(INT_CMD), RESOLUTION_CMD NO_PLURAL}
4567	,{jjstrlen, COUNT_CMD, XS(INT_CMD), STRING_CMD ALLOW_PLURAL}
4568	,{jjpLength, COUNT_CMD, XS(INT_CMD), POLY_CMD ALLOW_PLURAL}
4569	,{jjpLength, COUNT_CMD, XS(INT_CMD), VECTOR_CMD ALLOW_PLURAL}
4570	,{jjidElem, COUNT_CMD, XS(INT_CMD), IDEAL_CMD ALLOW_PLURAL}
4571	,{jjidElem, COUNT_CMD, XS(INT_CMD), MODUL_CMD ALLOW_PLURAL}
4572	,{jjCOUNT_M, COUNT_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4573	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
4574	,{jjCOUNT_IV, COUNT_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4575	,{jjCOUNT_L, COUNT_CMD, INT_CMD, LIST_CMD ALLOW_PLURAL}
4576	,{jjCOUNT_RG, COUNT_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4577	,{jjNULL, DEF_CMD, DEF_CMD, INT_CMD ALLOW_PLURAL}
4578	,{jjWRONG, DEF_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4579	,{jjDEG, DEG_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4580	,{jjDEG, DEG_CMD, INT_CMD, VECTOR_CMD ALLOW_PLURAL}
4581	,{jjDEG_M, DEG_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4582	,{jjDEGREE, DEGREE_CMD, NONE, IDEAL_CMD NO_PLURAL}
4583	,{jjDEGREE, DEGREE_CMD, NONE, MODUL_CMD NO_PLURAL}
4584	,{jjDEFINED, DEFINED_CMD, INT_CMD, DEF_CMD ALLOW_PLURAL}
4585	#ifdef HAVE_FACTORY
4586	,{jjDET_I, DET_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4587	,{jjDET, DET_CMD, POLY_CMD, MATRIX_CMD NO_PLURAL}
4588	,{jjDET_S, DET_CMD, POLY_CMD, MODUL_CMD NO_PLURAL}
4589	#else
4590	,{jjWRONG, DET_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4591	,{jjmpDetBareiss,DET_CMD, XS(POLY_CMD), MATRIX_CMD NO_PLURAL}
4592	#endif
4593	,{jjDIM, DIM_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
4594	,{jjDIM, DIM_CMD, INT_CMD, MODUL_CMD NO_PLURAL}
4595	,{jjDIM_R, DIM_CMD, XS(INT_CMD), RESOLUTION_CMD NO_PLURAL}
4596	,{jjDUMP, DUMP_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4597	,{jjE, E_CMD, VECTOR_CMD, INT_CMD ALLOW_PLURAL}
4598	,{jjEXECUTE, EXECUTE_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4599	,{jjERROR, ERROR_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4600	#ifdef HAVE_FACTORY
4601	,{jjFAC_P, FAC_CMD, LIST_CMD, POLY_CMD NO_PLURAL}
4602	#else
4603	,{jjWRONG, FAC_CMD, LIST_CMD, POLY_CMD NO_PLURAL}
4604	#endif
4605	#ifdef HAVE_FGLM
4606	,{findUniProc, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4607	#else
4608	,{jjWRONG, FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4609	#endif
4610	,{jjidFreeModule,FREEMODULE_CMD, XS(MODUL_CMD), INT_CMD ALLOW_PLURAL}
4611	#ifdef HAVE_FACTORY
4612	,{jjFACSTD, FACSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4613	#else
4614	,{jjWRONG, FACSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4615	#endif
4616	,{jjGETDUMP, GETDUMP_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4617	,{jjHIGHCORNER, HIGHCORNER_CMD, POLY_CMD, IDEAL_CMD NO_PLURAL}
4618	,{jjHIGHCORNER_M, HIGHCORNER_CMD,VECTOR_CMD, MODUL_CMD NO_PLURAL}
4619	,{jjHILBERT, HILBERT_CMD, NONE, IDEAL_CMD NO_PLURAL}
4620	,{jjHILBERT, HILBERT_CMD, NONE, MODUL_CMD NO_PLURAL}
4621	,{jjHILBERT_IV, HILBERT_CMD, INTVEC_CMD, INTVEC_CMD NO_PLURAL}
4622	,{jjHOMOG1, HOMOG_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4623	,{jjHOMOG1, HOMOG_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4624	,{jjidVec2Ideal,IDEAL_CMD, XS(IDEAL_CMD), VECTOR_CMD ALLOW_PLURAL}
4625	,{jjIDEAL_Ma, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD ALLOW_PLURAL}
4626	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, QRING_CMD ALLOW_PLURAL}
4627	,{jjIDEAL_R, IDEAL_CMD, IDEAL_CMD, RING_CMD ALLOW_PLURAL}
4628	,{jjIDEAL_Map, IDEAL_CMD, IDEAL_CMD, MAP_CMD ALLOW_PLURAL}
4629	,{jjDUMMY, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4630	,{jjIMPART, IMPART_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4631	,{jjINDEPSET, INDEPSET_CMD, INTVEC_CMD, IDEAL_CMD NO_PLURAL}
4632	,{jjDUMMY, INT_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
4633	,{jjnlInt, INT_CMD, INT_CMD, BIGINT_CMD ALLOW_PLURAL}
4634	,{jjnInt, INT_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4635	,{jjP2I, INT_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4636	,{jjINTERRED, INTERRED_CMD, IDEAL_CMD, IDEAL_CMD NO_PLURAL}
4637	,{jjINTERRED, INTERRED_CMD, MODUL_CMD, MODUL_CMD NO_PLURAL}
4638	,{jjDUMMY, INTMAT_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4639	,{jjIm2Iv, INTVEC_CMD, INTVEC_CMD, INTMAT_CMD ALLOW_PLURAL}
4640	,{jjDUMMY, INTVEC_CMD, INTVEC_CMD, INTVEC_CMD ALLOW_PLURAL}
4641	,{jjIS_RINGVAR_P, IS_RINGVAR, INT_CMD, POLY_CMD ALLOW_PLURAL}
4642	,{jjIS_RINGVAR_S, IS_RINGVAR, INT_CMD, STRING_CMD ALLOW_PLURAL}
4643	,{jjIS_RINGVAR0,IS_RINGVAR, INT_CMD, ANY_TYPE ALLOW_PLURAL}
4644	,{jjJACOB_P, JACOB_CMD, IDEAL_CMD, POLY_CMD ALLOW_PLURAL}
4645	,{mpJacobi, JACOB_CMD, MATRIX_CMD, IDEAL_CMD ALLOW_PLURAL}
4646	,{jjJanetBasis, JANET_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4647	,{jjKBASE, KBASE_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4648	,{jjKBASE, KBASE_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4649	,{atKILLATTR1, KILLATTR_CMD, NONE, IDHDL ALLOW_PLURAL}
4650	#ifdef MDEBUG
4651	,{jjpHead, LEAD_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4652	#else
4653	,{jjpHead, LEAD_CMD, XS(POLY_CMD), POLY_CMD ALLOW_PLURAL}
4654	#endif
4655	,{jjidHead, LEAD_CMD, XS(IDEAL_CMD), IDEAL_CMD ALLOW_PLURAL}
4656	#ifdef MDEBUG
4657	,{jjpHead, LEAD_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4658	#else
4659	,{jjpHead, LEAD_CMD, XS(VECTOR_CMD), VECTOR_CMD ALLOW_PLURAL}
4660	#endif
4661	,{jjidHead, LEAD_CMD, XS(MODUL_CMD), MODUL_CMD ALLOW_PLURAL}
4662	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, POLY_CMD ALLOW_PLURAL}
4663	,{jjLEADCOEF, LEADCOEF_CMD, NUMBER_CMD, VECTOR_CMD ALLOW_PLURAL}
4664	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, POLY_CMD ALLOW_PLURAL}
4665	,{jjLEADEXP, LEADEXP_CMD, INTVEC_CMD, VECTOR_CMD ALLOW_PLURAL}
4666	,{jjLEADMONOM, LEADMONOM_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4667	,{jjLEADMONOM, LEADMONOM_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4668	,{jjLOAD1, LIB_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4669	,{jjDUMMY, LINK_CMD, LINK_CMD, LINK_CMD ALLOW_PLURAL}
4670	,{jjCALL1MANY, LIST_CMD, LIST_CMD, DEF_CMD ALLOW_PLURAL}
4671	,{jjWRONG, MAP_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4672	,{jjDUMMY, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD ALLOW_PLURAL}
4673	,{jjidMaxIdeal, MAXID_CMD, XS(IDEAL_CMD), INT_CMD ALLOW_PLURAL}
4674	,{jjMEMORY, MEMORY_CMD, BIGINT_CMD, INT_CMD ALLOW_PLURAL}
4675	,{jjidMinBase, MINBASE_CMD, XS(IDEAL_CMD), IDEAL_CMD NO_PLURAL}
4676	,{jjidMinBase, MINBASE_CMD, XS(MODUL_CMD), MODUL_CMD NO_PLURAL}
4677	,{jjMINRES, MINRES_CMD, LIST_CMD, LIST_CMD ALLOW_PLURAL}
4678	,{jjMINRES_R, MINRES_CMD, RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4679	,{jjDUMMY, MODUL_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4680	,{jjMONITOR1, MONITOR_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4681	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, IDEAL_CMD NO_PLURAL}
4682	,{jjMULT, MULTIPLICITY_CMD, INT_CMD, MODUL_CMD NO_PLURAL}
4683	,{jjMSTD, MSTD_CMD, LIST_CMD, IDEAL_CMD NO_PLURAL}
4684	,{jjMSTD, MSTD_CMD, LIST_CMD, MODUL_CMD NO_PLURAL}
4685	,{jjNAMEOF, NAMEOF_CMD, STRING_CMD, ANY_TYPE ALLOW_PLURAL}
4686	,{jjNAMES, NAMES_CMD, LIST_CMD, PACKAGE_CMD ALLOW_PLURAL}
4687	,{jjNAMES, NAMES_CMD, LIST_CMD, RING_CMD ALLOW_PLURAL}
4688	,{jjNAMES, NAMES_CMD, LIST_CMD, QRING_CMD ALLOW_PLURAL}
4689	,{jjDUMMY, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4690	,{jjP2N, NUMBER_CMD, NUMBER_CMD, POLY_CMD ALLOW_PLURAL}
4691	,{jjRPAR, NPARS_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4692	,{jjRPAR, NPARS_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4693	,{jjNVARS, NVARS_CMD, INT_CMD, RING_CMD ALLOW_PLURAL}
4694	,{jjNVARS, NVARS_CMD, INT_CMD, QRING_CMD ALLOW_PLURAL}
4695	,{jjOpenClose, OPEN_CMD, NONE, LINK_CMD ALLOW_PLURAL}
4696	,{jjORD, ORD_CMD, INT_CMD, POLY_CMD ALLOW_PLURAL}
4697	,{jjORD, ORD_CMD, INT_CMD, VECTOR_CMD ALLOW_PLURAL}
4698	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4699	,{jjrOrdStr, ORDSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4700	,{jjPAR1, PAR_CMD, NUMBER_CMD, INT_CMD ALLOW_PLURAL}
4701	,{jjPARDEG, PARDEG_CMD, INT_CMD, NUMBER_CMD ALLOW_PLURAL}
4702	,{jjPARSTR1, PARSTR_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
4703	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4704	,{jjrParStr, PARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4705	,{jjDUMMY, POLY_CMD, POLY_CMD, POLY_CMD ALLOW_PLURAL}
4706	,{jjPREIMAGE_R, PREIMAGE_CMD, RING_CMD, MAP_CMD NO_PLURAL}
4707	,{jjPRIME, PRIME_CMD, INT_CMD, INT_CMD ALLOW_PLURAL}
4708	,{jjPRINT, PRINT_CMD, NONE, LIST_CMD ALLOW_PLURAL}
4709	,{jjPRINT, PRINT_CMD, NONE, DEF_CMD ALLOW_PLURAL}
4710	,{jjPRUNE, PRUNE_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4711	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4712	,{kQHWeight, QHWEIGHT_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4713	,{jjWRONG, QRING_CMD, 0, ANY_TYPE ALLOW_PLURAL}
4714	,{jjREAD, READ_CMD, STRING_CMD, LINK_CMD ALLOW_PLURAL}
4715	,{jjREGULARITY, REGULARITY_CMD, INT_CMD, LIST_CMD NO_PLURAL}
4716	,{jjREPART, REPART_CMD, NUMBER_CMD, NUMBER_CMD ALLOW_PLURAL}
4717	,{jjRESERVEDNAME,RESERVEDNAME_CMD, INT_CMD, STRING_CMD ALLOW_PLURAL}
4718	,{jjL2R, RESOLUTION_CMD, RESOLUTION_CMD, LIST_CMD ALLOW_PLURAL}
4719	,{jjDUMMY, RESOLUTION_CMD, RESOLUTION_CMD, RESOLUTION_CMD ALLOW_PLURAL}
4720	,{jjRINGLIST, RINGLIST_CMD, LIST_CMD, RING_CMD ALLOW_PLURAL}
4721	,{jjRINGLIST, RINGLIST_CMD, LIST_CMD, QRING_CMD ALLOW_PLURAL}
4722	,{jjDUMMY, RING_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4723	,{jjLISTRING, RING_CMD, RING_CMD, LIST_CMD ALLOW_PLURAL}
4724	//,{jjWRONG, ROWS_CMD, 0, POLY_CMD ALLOW_PLURAL}
4725	,{jjpMaxComp, ROWS_CMD, XS(INT_CMD), VECTOR_CMD ALLOW_PLURAL}
4726	,{jjROWS, ROWS_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4727	,{jjROWS, ROWS_CMD, INT_CMD, MATRIX_CMD ALLOW_PLURAL}
4728	,{jjROWS_IV, ROWS_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4729	,{jjCOUNT_IV, ROWS_CMD, INT_CMD, INTVEC_CMD ALLOW_PLURAL}
4730	,{jjSLIM_GB, SLIM_GB_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4731	,{jjSLIM_GB, SLIM_GB_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4732	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4733	,{jjSort_Id, SORTVEC_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4734	,{jjSTD, STD_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4735	,{jjSTD, STD_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4736	,{jjDUMMY, STRING_CMD, STRING_CMD, STRING_CMD ALLOW_PLURAL}
4737	,{jjSYSTEM, SYSTEM_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4738	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, IDEAL_CMD ALLOW_PLURAL}
4739	,{jjSYZYGY, SYZYGY_CMD, MODUL_CMD, MODUL_CMD ALLOW_PLURAL}
4740	#ifdef HAVE_PLURAL
4741	,{jjENVELOPE, ENVELOPE_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4742	,{jjENVELOPE, ENVELOPE_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
4743	,{jjOPPOSITE, OPPOSITE_CMD, RING_CMD, RING_CMD ALLOW_PLURAL}
4744	,{jjOPPOSITE, OPPOSITE_CMD, QRING_CMD, QRING_CMD ALLOW_PLURAL}
4745	,{jjTWOSTD, TWOSTD_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4746	#endif
4747	,{jjWRONG, TRACE_CMD, 0, INTVEC_CMD ALLOW_PLURAL}
4748	,{jjWRONG, TRACE_CMD, 0, IDEAL_CMD ALLOW_PLURAL}
4749	,{jjTRACE_IV, TRACE_CMD, INT_CMD, INTMAT_CMD ALLOW_PLURAL}
4750	,{jjmpTrace, TRACE_CMD, XS(POLY_CMD), MATRIX_CMD ALLOW_PLURAL}
4751	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTVEC_CMD ALLOW_PLURAL}
4752	,{jjTRANSP_IV, TRANSPOSE_CMD, INTMAT_CMD, INTMAT_CMD ALLOW_PLURAL}
4753	,{jjmpTransp, TRANSPOSE_CMD, XS(MATRIX_CMD), MATRIX_CMD ALLOW_PLURAL}
4754	,{jjidTransp, TRANSPOSE_CMD, XS(MODUL_CMD), MODUL_CMD ALLOW_PLURAL}
4755	,{jjTYPEOF, TYPEOF_CMD, STRING_CMD, ANY_TYPE ALLOW_PLURAL}
4756	,{jjDUMMY, VECTOR_CMD, VECTOR_CMD, VECTOR_CMD ALLOW_PLURAL}
4757	,{jjVDIM, VDIM_CMD, INT_CMD, IDEAL_CMD ALLOW_PLURAL}
4758	,{jjVDIM, VDIM_CMD, INT_CMD, MODUL_CMD ALLOW_PLURAL}
4759	,{jjVAR1, VAR_CMD, POLY_CMD, INT_CMD ALLOW_PLURAL}
4760	,{jjVARSTR1, VARSTR_CMD, STRING_CMD, INT_CMD ALLOW_PLURAL}
4761	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), RING_CMD ALLOW_PLURAL}
4762	,{jjrVarStr, VARSTR_CMD, XS(STRING_CMD), QRING_CMD ALLOW_PLURAL}
4763	,{kWeight, WEIGHT_CMD, INTVEC_CMD, IDEAL_CMD ALLOW_PLURAL}
4764	,{kWeight, WEIGHT_CMD, INTVEC_CMD, MODUL_CMD ALLOW_PLURAL}
4765	,{jjLOAD1, LOAD_CMD, NONE, STRING_CMD ALLOW_PLURAL}
4766	,{loNewtonP, NEWTONPOLY_CMD, IDEAL_CMD, IDEAL_CMD ALLOW_PLURAL}
4767	,{NULL, 0, 0, 0 NO_PLURAL}
4768	};
4769	#undef s
4770	/=================== operations with 3 args.: static proc =================/
4771	static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v,leftv w)
4772	{
4773	char s= (char )u->Data();
4774	int r = (int)(long)v->Data();
4775	int c = (int)(long)w->Data();
4776	int l = strlen(s);
4777
4778	if ( (r<1) \|\| (r>l) \|\| (c<0) )
4779	{
4780	Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
4781	return TRUE;
4782	}
4783	res->data = (char *)omAlloc(c+1);
4784	sprintf((char )res->data,"%-.*s",c,c,s+r-1);
4785	return FALSE;
4786	}
4787	static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v,leftv w)
4788	{
4789	intvec iv = (intvec )u->Data();
4790	int r = (int)(long)v->Data();
4791	int c = (int)(long)w->Data();
4792	if ((r<1)\|\|(r>iv->rows())\|\|(c<1)\|\|(c>iv->cols()))
4793	{
4794	Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
4795	r,c,u->Fullname(),iv->rows(),iv->cols());
4796	return TRUE;
4797	}
4798	res->data=u->data; u->data=NULL;
4799	res->rtyp=u->rtyp; u->rtyp=0;
4800	res->name=u->name; u->name=NULL;
4801	res->attribute=u->attribute; u->attribute=NULL;
4802	Subexpr e=jjMakeSub(v);
4803	e->next=jjMakeSub(w);
4804	if (u->e==NULL) res->e=e;
4805	else
4806	{
4807	Subexpr h=u->e;
4808	while (h->next!=NULL) h=h->next;
4809	h->next=e;
4810	res->e=u->e;
4811	u->e=NULL;
4812	}
4813	return FALSE;
4814	}
4815	static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v,leftv w)
4816	{
4817	matrix m= (matrix)u->Data();
4818	int r = (int)(long)v->Data();
4819	int c = (int)(long)w->Data();
4820	//Print("gen. elem %d, %d\n",r,c);
4821	if ((r<1)\|\|(r>MATROWS(m))\|\|(c<1)\|\|(c>MATCOLS(m)))
4822	{
4823	Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
4824	MATROWS(m),MATCOLS(m));
4825	return TRUE;
4826	}
4827	res->data=u->data; u->data=NULL;
4828	res->rtyp=u->rtyp; u->rtyp=0;
4829	res->name=u->name; u->name=NULL;
4830	res->attribute=u->attribute; u->attribute=NULL;
4831	Subexpr e=jjMakeSub(v);
4832	e->next=jjMakeSub(w);
4833	if (u->e==NULL)
4834	res->e=e;
4835	else
4836	{
4837	Subexpr h=u->e;
4838	while (h->next!=NULL) h=h->next;
4839	h->next=e;
4840	res->e=u->e;
4841	u->e=NULL;
4842	}
4843	return FALSE;
4844	}
4845	static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v,leftv w)
4846	{
4847	sleftv t;
4848	sleftv ut;
4849	leftv p=NULL;
4850	intvec iv=(intvec )w->Data();
4851	int l;
4852	BOOLEAN nok;
4853
4854	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4855	{
4856	WerrorS("cannot build expression lists from unnamed objects");
4857	return TRUE;
4858	}
4859	memcpy(&ut,u,sizeof(ut));
4860	memset(&t,0,sizeof(t));
4861	t.rtyp=INT_CMD;
4862	for (l=0;l< iv->length(); l++)
4863	{
4864	t.data=(char )(iv)[l];
4865	if (p==NULL)
4866	{
4867	p=res;
4868	}
4869	else
4870	{
4871	p->next=(leftv)omAlloc0Bin(sleftv_bin);
4872	p=p->next;
4873	}
4874	memcpy(u,&ut,sizeof(ut));
4875	if (u->Typ() == MATRIX_CMD)
4876	nok=jjBRACK_Ma(p,u,v,&t);
4877	else /* INTMAT_CMD */
4878	nok=jjBRACK_Im(p,u,v,&t);
4879	if (nok)
4880	{
4881	while (res->next!=NULL)
4882	{
4883	p=res->next->next;
4884	omFreeBin((ADDRESS)res->next, sleftv_bin);
4885	// res->e aufraeumen !!!!
4886	res->next=p;
4887	}
4888	return TRUE;
4889	}
4890	}
4891	return FALSE;
4892	}
4893	static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v,leftv w)
4894	{
4895	sleftv t;
4896	sleftv ut;
4897	leftv p=NULL;
4898	intvec iv=(intvec )v->Data();
4899	int l;
4900	BOOLEAN nok;
4901
4902	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4903	{
4904	WerrorS("cannot build expression lists from unnamed objects");
4905	return TRUE;
4906	}
4907	memcpy(&ut,u,sizeof(ut));
4908	memset(&t,0,sizeof(t));
4909	t.rtyp=INT_CMD;
4910	for (l=0;l< iv->length(); l++)
4911	{
4912	t.data=(char )((iv)[l]);
4913	if (p==NULL)
4914	{
4915	p=res;
4916	}
4917	else
4918	{
4919	p->next=(leftv)omAlloc0Bin(sleftv_bin);
4920	p=p->next;
4921	}
4922	memcpy(u,&ut,sizeof(ut));
4923	if (u->Typ() == MATRIX_CMD)
4924	nok=jjBRACK_Ma(p,u,&t,w);
4925	else /* INTMAT_CMD */
4926	nok=jjBRACK_Im(p,u,&t,w);
4927	if (nok)
4928	{
4929	while (res->next!=NULL)
4930	{
4931	p=res->next->next;
4932	omFreeBin((ADDRESS)res->next, sleftv_bin);
4933	// res->e aufraeumen !!
4934	res->next=p;
4935	}
4936	return TRUE;
4937	}
4938	}
4939	return FALSE;
4940	}
4941	static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v,leftv w)
4942	{
4943	sleftv t1,t2,ut;
4944	leftv p=NULL;
4945	intvec vv=(intvec )v->Data();
4946	intvec wv=(intvec )w->Data();
4947	int vl;
4948	int wl;
4949	BOOLEAN nok;
4950
4951	if ((u->rtyp!=IDHDL)\|\|(u->e!=NULL))
4952	{
4953	WerrorS("cannot build expression lists from unnamed objects");
4954	return TRUE;
4955	}
4956	memcpy(&ut,u,sizeof(ut));
4957	memset(&t1,0,sizeof(sleftv));
4958	memset(&t2,0,sizeof(sleftv));
4959	t1.rtyp=INT_CMD;
4960	t2.rtyp=INT_CMD;
4961	for (vl=0;vl< vv->length(); vl++)
4962	{
4963	t1.data=(char )((vv)[vl]);
4964	for (wl=0;wl< wv->length(); wl++)
4965	{
4966	t2.data=(char )((wv)[wl]);
4967	if (p==NULL)
4968	{
4969	p=res;
4970	}
4971	else
4972	{
4973	p->next=(leftv)omAlloc0Bin(sleftv_bin);
4974	p=p->next;
4975	}
4976	memcpy(u,&ut,sizeof(ut));
4977	if (u->Typ() == MATRIX_CMD)
4978	nok=jjBRACK_Ma(p,u,&t1,&t2);
4979	else /* INTMAT_CMD */
4980	nok=jjBRACK_Im(p,u,&t1,&t2);
4981	if (nok)
4982	{
4983	res->CleanUp();
4984	return TRUE;
4985	}
4986	}
4987	}
4988	return FALSE;
4989	}
4990	static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
4991	{
4992	v->next=(leftv)omAllocBin(sleftv_bin);
4993	memcpy(v->next,w,sizeof(sleftv));
4994	memset(w,0,sizeof(sleftv));
4995	return jjPROC(res,u,v);
4996	}
4997	static BOOLEAN jjCALL3MANY(leftv res, leftv u, leftv v, leftv w)
4998	{
4999	u->next=(leftv)omAllocBin(sleftv_bin);
5000	memcpy(u->next,v,sizeof(sleftv));
5001	u->next->next=(leftv)omAllocBin(sleftv_bin);
5002	memcpy(u->next->next,w,sizeof(sleftv));
5003	BOOLEAN r=iiExprArithM(res,u,iiOp);
5004	// iiExprArithM did the CleanUp
5005	w->rtyp=0; w->data=NULL;
5006	return r;
5007	}
5008	static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
5009	{
5010	intvec *iv;
5011	ideal m;
5012	lists l=(lists)omAllocBin(slists_bin);
5013	int k=(int)(long)w->Data();
5014	if (k>=0)
5015	{
5016	smCallNewBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv);
5017	l->Init(2);
5018	l->m[0].rtyp=MODUL_CMD;
5019	l->m[1].rtyp=INTVEC_CMD;
5020	l->m[0].data=(void *)m;
5021	l->m[1].data=(void *)iv;
5022	}
5023	else
5024	{
5025	m=smCallSolv((ideal)u->Data());
5026	l->Init(1);
5027	l->m[0].rtyp=IDEAL_CMD;
5028	l->m[0].data=(void *)m;
5029	}
5030	res->data = (char *)l;
5031	return FALSE;
5032	}
5033	static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
5034	{
5035	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
5036	{
5037	WerrorS("3rd argument must be a name of a matrix");
5038	return TRUE;
5039	}
5040	ideal i=(ideal)u->Data();
5041	int rank=(int)i->rank;
5042	BOOLEAN r=jjCOEFFS_Id(res,u,v);
5043	if (r) return TRUE;
5044	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5045	return FALSE;
5046	}
5047	static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
5048	{
5049	res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
5050	(ideal)(v->Data()),(poly)(w->Data()));
5051	return FALSE;
5052	}
5053	static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
5054	{
5055	if ((w->rtyp!=IDHDL)\|\|(w->e!=NULL))
5056	{
5057	WerrorS("3rd argument must be a name of a matrix");
5058	return TRUE;
5059	}
5060	// CopyD for POLY_CMD and VECTOR_CMD are identical:
5061	poly p=(poly)u->CopyD(POLY_CMD);
5062	ideal i=idInit(1,1);
5063	i->m[0]=p;
5064	sleftv t;
5065	memset(&t,0,sizeof(t));
5066	t.data=(char *)i;
5067	t.rtyp=IDEAL_CMD;
5068	int rank=1;
5069	if (u->Typ()==VECTOR_CMD)
5070	{
5071	i->rank=rank=pMaxComp(p);
5072	t.rtyp=MODUL_CMD;
5073	}
5074	BOOLEAN r=jjCOEFFS_Id(res,&t,v);
5075	t.CleanUp();
5076	if (r) return TRUE;
5077	mpMonomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data());
5078	return FALSE;
5079	}
5080	static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
5081	{
5082	res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
5083	(intvec *)w->Data());
5084	setFlag(res,FLAG_STD);
5085	return FALSE;
5086	}
5087	static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
5088	{
5089	/*4
5090	* look for the substring what in the string where
5091	* starting at position n
5092	* return the position of the first char of what in where
5093	* or 0
5094	*/
5095	int n=(int)(long)w->Data();
5096	char where=(char )u->Data();
5097	char what=(char )v->Data();
5098	char *found;
5099	if ((1>n)\|\|(n>(int)strlen(where)))
5100	{
5101	Werror("start position %d out of range",n);
5102	return TRUE;
5103	}
5104	found = strchr(where+n-1,*what);
5105	if (*(what+1)!='\0')
5106	{
5107	while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
5108	{
5109	found=strchr(found+1,*what);
5110	}
5111	}
5112	if (found != NULL)
5113	{
5114	res->data=(char *)((found-where)+1);
5115	}
5116	return FALSE;
5117	}
5118	static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
5119	{
5120	if ((int)(long)w->Data()==0)
5121	res->data=(char *)walkProc(u,v);
5122	else
5123	res->data=(char *)fractalWalkProc(u,v);
5124	setFlag( res, FLAG_STD );
5125	return FALSE;
5126	}
5127	static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
5128	{
5129	assumeStdFlag(u);
5130	intvec module_w=(intvec )atGet(u,"isHomog",INTVEC_CMD);
5131	intvec wdegree=(intvec)w->Data();
5132	if (wdegree->length()!=pVariables)
5133	{
5134	Werror("weight vector must have size %d, not %d",
5135	pVariables,wdegree->length());
5136	return TRUE;
5137	}
5138	intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currQuotient,wdegree);
5139	switch((int)(long)v->Data())
5140	{
5141	case 1:
5142	res->data=(void *)iv;
5143	return FALSE;
5144	case 2:
5145	res->data=(void *)hSecondSeries(iv);
5146	delete iv;
5147	return FALSE;
5148	}
5149	WerrorS(feNotImplemented);
5150	delete iv;
5151	return TRUE;
5152	}
5153	static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v,leftv w)
5154	{
5155	intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
5156	intvec* arg = (intvec*) u->Data();
5157	int i, n = si_min(im->cols()im->rows(), arg->cols()arg->rows());
5158
5159	for (i=0; i<n; i++)
5160	{
5161	(im)[i] = (arg)[i];
5162	}
5163
5164	res->data = (char *)im;
5165	return FALSE;
5166	}
5167	static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
5168	{
5169	short iw=iv2array((intvec )w->Data());
5170	res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
5171	omFreeSize((ADDRESS)iw,(pVariables+1)*sizeof(short));
5172	return FALSE;
5173	}
5174	static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
5175	{
5176	if (!pIsUnit((poly)v->Data()))
5177	{
5178	WerrorS("2nd argument must be a unit");
5179	return TRUE;
5180	}
5181	res->data = (char *)pSeries((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD());
5182	return FALSE;
5183	}
5184	static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
5185	{
5186	res->data = (char *)idJetW((ideal)u->Data(),(int)(long)v->Data(),
5187	(intvec *)w->Data());
5188	return FALSE;
5189	}
5190	static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
5191	{
5192	if (!mpIsDiagUnit((matrix)v->Data()))
5193	{
5194	WerrorS("2nd argument must be a diagonal matrix of units");
5195	return TRUE;
5196	}
5197	res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
5198	(matrix)v->CopyD());
5199	return FALSE;
5200	}
5201	static BOOLEAN jjMINOR3(leftv res, leftv u, leftv v, leftv w)
5202	{
5203	assumeStdFlag(w);
5204	res->data = (char *)idMinors(
5205	(matrix)u->Data(),(int)(long)v->Data(),(ideal)w->Data());
5206	return FALSE;
5207	}
5208	static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
5209	{
5210	idhdl h;
5211	ring rr;
5212	map mapping;
5213
5214	if ((v->name==NULL) \|\| (w->name==NULL))
5215	{
5216	WerrorS("2nd/3rd arguments must have names");
5217	return TRUE;
5218	}
5219	rr=(ring)u->Data();
5220	const char *ring_name=u->Name();
5221	if ((h=rr->idroot->get(v->name,myynest))!=NULL)
5222	{
5223	if (h->typ==MAP_CMD)
5224	{
5225	mapping=IDMAP(h);
5226	idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
5227	if ((preim_ring==NULL)
5228	\|\| (IDRING(preim_ring)!=currRing))
5229	{
5230	Werror("preimage ring `%s` is not the basering",mapping->preimage);
5231	return TRUE;
5232	}
5233	}
5234	else if (h->typ==IDEAL_CMD)
5235	{
5236	mapping=IDMAP(h);
5237	}
5238	else
5239	{
5240	Werror("`%s` is no map nor ideal",IDID(h));
5241	return TRUE;
5242	}
5243	}
5244	else
5245	{
5246	Werror("`%s` is not defined in `%s`",v->name,ring_name);
5247	return TRUE;
5248	}
5249	if ((h=rr->idroot->get(w->name,myynest))!=NULL)
5250	{
5251	if (h->typ==IDEAL_CMD)
5252	{
5253	if (((currRing->qideal!=NULL) && (pOrdSgn==-1))
5254	\|\| ((rr->qideal!=NULL) && (rr->OrdSgn==-1)))
5255	{
5256	WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
5257	}
5258	res->data=(char *)maGetPreimage(rr,mapping,IDIDEAL(h));
5259	if (res->data==NULL/* is of type ideal, should not be NULL*/) return TRUE;
5260	}
5261	else
5262	{
5263	Werror("`%s` is no ideal",IDID(h));
5264	return TRUE;
5265	}
5266	}
5267	else
5268	{
5269	Werror("`%s` is not defined in `%s`",w->name,ring_name);
5270	return TRUE;
5271	}
5272	return FALSE;
5273	}
5274	static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
5275	{
5276	int di, k;
5277	int i=(int)(long)u->Data();
5278	int r=(int)(long)v->Data();
5279	int c=(int)(long)w->Data();
5280	if ((r<=0) \|\| (c<=0)) return TRUE;
5281	intvec *iv = new intvec(r, c, 0);
5282	if (iv->rows()==0)
5283	{
5284	delete iv;
5285	return TRUE;
5286	}
5287	if (i!=0)
5288	{
5289	if (i<0) i = -i;
5290	di = 2 * i + 1;
5291	for (k=0; k<iv->length(); k++)
5292	{
5293	#ifdef buildin_rand
5294	(*iv)[k] = ((siRand() % di) - i);
5295	#else
5296	(*iv)[k] = ((rand() % di) - i);
5297	#endif
5298	}
5299	}
5300	res->data = (char *)iv;
5301	return FALSE;
5302	}
5303	static BOOLEAN jjSUBST_Test(leftv v,leftv w,
5304	int &ringvar, poly &monomexpr)
5305	{
5306	monomexpr=(poly)w->Data();
5307	poly p=(poly)v->Data();
5308	#if 0
5309	if (pLength(monomexpr)>1)
5310	{
5311	Werror("`%s` substitutes a ringvar only by a term",
5312	Tok2Cmdname(SUBST_CMD));
5313	return TRUE;
5314	}
5315	#endif
5316	if (!(ringvar=pVar(p)))
5317	{
5318	if (rField_is_Extension(currRing))
5319	{
5320	assume(currRing->algring!=NULL);
5321	lnumber n=(lnumber)pGetCoeff(p);
5322	ringvar=-p_Var(n->z,currRing->algring);
5323	}
5324	if(ringvar==0)
5325	{
5326	WerrorS("ringvar/par expected");
5327	return TRUE;
5328	}
5329	}
5330	return FALSE;
5331	}
5332	static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v,leftv w)
5333	{
5334	int ringvar;
5335	poly monomexpr;
5336	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5337	if (nok) return TRUE;
5338	if (ringvar>0)
5339	{
5340	if ((monomexpr==NULL)\|\|(pNext(monomexpr)==NULL))
5341	res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
5342	else
5343	res->data= pSubstPoly((poly)u->Data(),ringvar,monomexpr);
5344	}
5345	else
5346	{
5347	res->data=pSubstPar((poly)u->Data(),-ringvar,monomexpr);
5348	}
5349	return FALSE;
5350	}
5351	static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v,leftv w)
5352	{
5353	int ringvar;
5354	poly monomexpr;
5355	BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
5356	if (nok) return TRUE;
5357	if (ringvar>0)
5358	{
5359	if ((monomexpr==NULL)\|\|(pNext(monomexpr)==NULL))
5360	res->data = idSubst((ideal)u->CopyD(res->rtyp),ringvar,monomexpr);
5361	else
5362	res->data = idSubstPoly((ideal)u->Data(),ringvar,monomexpr);
5363	}
5364	else
5365	{
5366	res->data = idSubstPar((ideal)u->Data(),-ringvar,monomexpr);
5367	}
5368	return FALSE;
5369	}
5370	// we do not want to have jjSUBST_Id_X inlined:
5371	static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w,
5372	int input_type);
5373	static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v,leftv w)
5374	{
5375	return jjSUBST_Id_X(res,u,v,w,INT_CMD);
5376	}
5377	static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v,leftv w)
5378	{
5379	return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
5380	}
5381	static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v,leftv w, int input_type)
5382	{
5383	sleftv tmp;
5384	memset(&tmp,0,sizeof(tmp));
5385	// do not check the result, conversion from int/number to poly works always
5386	iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
5387	BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
5388	tmp.CleanUp();
5389	return b;
5390	}
5391	static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v,leftv w)
5392	{
5393	matrix m=mpNew((int)(long)v->Data(),(int)(long)w->Data());
5394	ideal I=(ideal)u->CopyD(IDEAL_CMD);
5395	int i=si_min(IDELEMS(I),(int)(long)v->Data()*(int)(long)w->Data());
5396	//for(i=i-1;i>=0;i--)
5397	//{
5398	// m->m[i]=I->m[i];
5399	// I->m[i]=NULL;
5400	//}
5401	memcpy4(m->m,I->m,i*sizeof(poly));
5402	memset(I->m,0,i*sizeof(poly));
5403	idDelete(&I);
5404	res->data = (char *)m;
5405	return FALSE;
5406	}
5407	static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v,leftv w)
5408	{
5409	res->data = (char *)idModule2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
5410	(int)(long)v->Data(),(int)(long)w->Data());
5411	return FALSE;
5412	}
5413