source: git/Singular/iparith.cc @ cebb98

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