Loading...
Searching...
No Matches
ipshell.h File Reference
`#include <stdio.h>`
`#include "kernel/ideals.h"`
`#include "Singular/lists.h"`
`#include "Singular/fevoices.h"`

Go to the source code of this file.

## Data Structures

struct | sValCmd1
struct | sValCmd2
struct | sValCmd3
struct | sValCmdM
struct | sValAssign_sys
struct | sValAssign

## Typedefs

typedef BOOLEAN(* | proc1) (leftv, leftv)
typedef BOOLEAN(* | proc2) (leftv, leftv, leftv)
typedef BOOLEAN(* | proc3) (leftv, leftv, leftv, leftv)
typedef BOOLEAN(* | proci) (leftv, leftv, Subexpr)

## Functions

BOOLEAN | spectrumProc (leftv, leftv)
BOOLEAN | spectrumfProc (leftv, leftv)
BOOLEAN | spaddProc (leftv, leftv, leftv)
BOOLEAN | spmulProc (leftv, leftv, leftv)
BOOLEAN | semicProc (leftv, leftv, leftv)
BOOLEAN | semicProc3 (leftv, leftv, leftv, leftv)
BOOLEAN | iiAssignCR (leftv, leftv)
BOOLEAN | iiARROW (leftv, char *, char *)
int | IsCmd (const char *n, int &tok)
BOOLEAN | iiPStart (idhdl pn, leftv sl)
BOOLEAN | iiEStart (char *example, procinfo *pi)
BOOLEAN | iiAllStart (procinfov pi, const char *p, feBufferTypes t, int l)
void | type_cmd (leftv v)
void | test_cmd (int i)
void | list_cmd (int typ, const char *what, const char *prefix, BOOLEAN iterate, BOOLEAN fullname=FALSE)
void | killlocals (int v)
int | exprlist_length (leftv v)
const char * | Tok2Cmdname (int i)
const char * | iiTwoOps (int t)
int | iiOpsTwoChar (const char *s)
BOOLEAN | iiWRITE (leftv res, leftv exprlist)
BOOLEAN | iiExport (leftv v, int toLev)
BOOLEAN | iiExport (leftv v, int toLev, package pack)
BOOLEAN | iiInternalExport (leftv v, int toLev, package pack)
static char * | iiGetLibName (const procinfov pi)
| find the library of an proc
char * | iiGetLibProcBuffer (procinfov pi, int part=1)
char * | iiProcName (char *buf, char &ct, char *&e)
char * | iiProcArgs (char *e, BOOLEAN withParenth)
BOOLEAN | iiLibCmd (const char *newlib, BOOLEAN autoexport, BOOLEAN tellerror, BOOLEAN force)
BOOLEAN | jjLOAD (const char *s, BOOLEAN autoexport=FALSE)
| load lib/module given in v
BOOLEAN | jjLOAD_TRY (const char *s)
BOOLEAN | iiLocateLib (const char *lib, char *where)
leftv | iiMap (map theMap, const char *what)
void | iiMakeResolv (resolvente r, int length, int rlen, char *name, int typ0, intvec **weights=NULL)
BOOLEAN | jjMINRES (leftv res, leftv v)
BOOLEAN | jjBETTI (leftv res, leftv v)
BOOLEAN | jjBETTI2 (leftv res, leftv u, leftv v)
BOOLEAN | jjBETTI2_ID (leftv res, leftv u, leftv v)
BOOLEAN | jjIMPORTFROM (leftv res, leftv u, leftv v)
BOOLEAN | jjLIST_PL (leftv res, leftv v)
BOOLEAN | jjVARIABLES_P (leftv res, leftv u)
BOOLEAN | jjVARIABLES_ID (leftv res, leftv u)
int | iiRegularity (lists L)
leftv | singular_system (sleftv h)
BOOLEAN | jjSYSTEM (leftv res, leftv v)
void | iiDebug ()
BOOLEAN | iiCheckRing (int i)
poly | iiHighCorner (ideal i, int ak)
| the largest monomial in R/I
char * | iiConvName (const char *libname)
BOOLEAN | iiGetLibStatus (const char *lib)
BOOLEAN | iiLoadLIB (FILE *fp, const char *libnamebuf, const char *newlib, idhdl pl, BOOLEAN autoexport, BOOLEAN tellerror)
lists | syConvRes (syStrategy syzstr, BOOLEAN toDel=FALSE, int add_row_shift=0)
syStrategy | syConvList (lists li)
BOOLEAN | syBetti1 (leftv res, leftv u)
BOOLEAN | syBetti2 (leftv res, leftv u, leftv w)
int | siSetCpus (int cpu)
BOOLEAN | iiExprArith1 (leftv res, sleftv *a, int op)
BOOLEAN | iiExprArith2 (leftv res, sleftv *a, int op, sleftv *b, BOOLEAN proccall=FALSE)
BOOLEAN | iiExprArith3 (leftv res, int op, leftv a, leftv b, leftv c)
BOOLEAN | iiExprArithM (leftv res, sleftv *a, int op)
BOOLEAN | iiApply (leftv res, leftv a, int op, leftv proc)
BOOLEAN | iiAssign (leftv left, leftv right, BOOLEAN toplevel=TRUE)
coeffs | jjSetMinpoly (coeffs cf, number a)
BOOLEAN | iiParameter (leftv p)
BOOLEAN | iiAlias (leftv p)
int | iiTokType (int op)
int | iiDeclCommand (leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring=FALSE, BOOLEAN init_b=TRUE)
BOOLEAN | iiMake_proc (idhdl pn, package pack, leftv sl)
void * | iiCallLibProc1 (const char *n, void *arg, int arg_type, BOOLEAN &err)
leftv | ii_CallLibProcM (const char *n, void **args, int *arg_types, const ring R, BOOLEAN &err)
| args: NULL terminated array of arguments arg_types: 0 terminated array of corresponding types
ideal | ii_CallProcId2Id (const char *lib, const char *proc, ideal arg, const ring R)
int | ii_CallProcId2Int (const char *lib, const char *proc, ideal arg, const ring R)
char * | showOption ()
BOOLEAN | setOption (leftv res, leftv v)
char * | versionString ()
void | singular_example (char *str)
BOOLEAN | iiTryLoadLib (leftv v, const char *id)
int | iiAddCproc (const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
void | iiCheckPack (package &p)
void | rSetHdl (idhdl h)
ring | rInit (leftv pn, leftv rv, leftv ord)
idhdl | rDefault (const char *s)
idhdl | rFindHdl (ring r, idhdl n)
void | rKill (idhdl h)
void | rKill (ring r)
lists | scIndIndset (ideal S, BOOLEAN all, ideal Q)
BOOLEAN | mpKoszul (leftv res, leftv c, leftv b, leftv id)
BOOLEAN | mpJacobi (leftv res, leftv a)
BOOLEAN | jjRESULTANT (leftv res, leftv u, leftv v, leftv w)
BOOLEAN | kQHWeight (leftv res, leftv v)
BOOLEAN | kWeight (leftv res, leftv id)
BOOLEAN | loSimplex (leftv res, leftv args)
| Implementation of the Simplex Algorithm.
BOOLEAN | loNewtonP (leftv res, leftv arg1)
| compute Newton Polytopes of input polynomials
BOOLEAN | nuMPResMat (leftv res, leftv arg1, leftv arg2)
| returns module representing the multipolynomial resultant matrix Arguments 2: ideal i, int k k=0: use sparse resultant matrix of Gelfand, Kapranov and Zelevinsky k=1: use resultant matrix of Macaulay (k=0 is default)
BOOLEAN | nuLagSolve (leftv res, leftv arg1, leftv arg2, leftv arg3)
| find the (complex) roots an univariate polynomial Determines the roots of an univariate polynomial using Laguerres' root-solver.
BOOLEAN | nuVanderSys (leftv res, leftv arg1, leftv arg2, leftv arg3)
| COMPUTE: polynomial p with values given by v at points p1,..,pN derived from p; more precisely: consider p as point in K^n and v as N elements in K, let p1,..,pN be the points in K^n obtained by evaluating all monomials of degree 0,1,...,N at p in lexicographical order, then the procedure computes the polynomial f satisfying f(pi) = v[i] RETURN: polynomial f of degree d.
BOOLEAN | nuUResSolve (leftv res, leftv args)
| solve a multipolynomial system using the u-resultant Input ideal must be 0-dimensional and (currRing->N) == IDELEMS(ideal).
BOOLEAN | jjCHARSERIES (leftv res, leftv u)
void | paPrint (const char *n, package p)
BOOLEAN | iiTestAssume (leftv a, leftv b)
BOOLEAN | iiExprArith1Tab (leftv res, leftv a, int op, const struct sValCmd1 *dA1, int at, const struct sConvertTypes *dConvertTypes)
| apply an operation 'op' to an argument a return TRUE on failure
BOOLEAN | iiExprArith2Tab (leftv res, leftv a, int op, const struct sValCmd2 *dA2, int at, const struct sConvertTypes *dConvertTypes)
| apply an operation 'op' to arguments a and a->next return TRUE on failure
BOOLEAN | iiExprArith3Tab (leftv res, leftv a, int op, const struct sValCmd3 *dA3, int at, const struct sConvertTypes *dConvertTypes)
| apply an operation 'op' to arguments a, a->next and a->next->next return TRUE on failure
BOOLEAN | iiCheckTypes (leftv args, const short *type_list, int report=0)
| check a list of arguemys against a given field of types return TRUE if the types match return FALSE (and, if report) report an error via Werror otherwise
BOOLEAN | iiBranchTo (leftv r, leftv args)
lists | rDecompose (const ring r)
lists | rDecompose_list_cf (const ring r)
BOOLEAN | rDecompose_CF (leftv res, const coeffs C)
ring | rCompose (const lists L, const BOOLEAN check_comp=TRUE, const long bitmask=0x7fff, const int isLetterplace=FALSE)
void | iiSetReturn (const leftv h)

## Variables

EXTERN_VAR leftv | iiCurrArgs
EXTERN_VAR idhdl | iiCurrProc
EXTERN_VAR int | iiOp
const char * | currid
EXTERN_VAR int | iiRETURNEXPR_len
EXTERN_INST_VAR sleftv | iiRETURNEXPR
EXTERN_VAR ring * | iiLocalRing
const char * | lastreserved
EXTERN_VAR int | myynest
EXTERN_VAR int | printlevel
EXTERN_VAR int | si_echo
EXTERN_VAR BOOLEAN | yyInRingConstruction
const struct sValCmd2 | dArith2 []
const struct sValCmd1 | dArith1 []
const struct sValCmd3 | dArith3 []
const struct sValCmdM | dArithM []

## Data Structure Documentation

## sValCmd1

struct sValCmd1

Definition at line 75 of file gentable.cc.

Data Fields
short | arg |
short | cmd |
int | p |
proc1 | p |
short | res |
short | valid_for |

## sValCmd2

struct sValCmd2

Definition at line 66 of file gentable.cc.

Data Fields
short | arg1 |
short | arg2 |
short | cmd |
int | p |
proc2 | p |
short | res |
short | valid_for |

## sValCmd3

struct sValCmd3

Definition at line 83 of file gentable.cc.

Data Fields
short | arg1 |
short | arg2 |
short | arg3 |
short | cmd |
int | p |
proc3 | p |
short | res |
short | valid_for |

## sValCmdM

struct sValCmdM

Definition at line 93 of file gentable.cc.

Data Fields
short | cmd |
short | number_of_args |
int | p |
proc1 | p |
short | res |
short | valid_for |

## sValAssign_sys

struct sValAssign_sys

Definition at line 101 of file gentable.cc.

Data Fields
short | arg |
int | p |
proc1 | p |
short | res |

## sValAssign

struct sValAssign

Definition at line 108 of file gentable.cc.

Data Fields
short | arg |
int | p |
proci | p |
short | res |

## Typedef Documentation

## proc1

typedef BOOLEAN(* proc1) (leftv, leftv)

Definition at line 124 of file ipshell.h.

## proc2

typedef BOOLEAN(* proc2) (leftv, leftv, leftv)

Definition at line 136 of file ipshell.h.

## proc3

typedef BOOLEAN(* proc3) (leftv, leftv, leftv, leftv)

Definition at line 147 of file ipshell.h.

## proci

typedef BOOLEAN(* proci) (leftv, leftv, Subexpr)

Definition at line 177 of file ipshell.h.

## Function Documentation

## exprlist_length()

int exprlist_length | ( | leftv | v | ) |

Definition at line 551 of file ipshell.cc.

{
int rc = 0;
while (v!=NULL)
{
switch (v->Typ())
{
case INT_CMD:
case POLY_CMD:
case VECTOR_CMD:
case NUMBER_CMD:
rc++;
break;
case INTVEC_CMD:
case INTMAT_CMD:
rc += ((intvec *)(v->Data()))->length();
break;
case MATRIX_CMD:
case IDEAL_CMD:
case MODUL_CMD:
{
matrix mm = (matrix)(v->Data());
rc += mm->rows() * mm->cols();
}
break;
case LIST_CMD:
rc+=((lists)v->Data())->nr+1;
break;
default:
rc++;
}
v = v->next;
}
return rc;
}
intvec
Definition intvec.h:24
ip_smatrix::cols
int & cols()
Definition matpol.h:24
ip_smatrix::rows
int & rows()
Definition matpol.h:23
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
IDEAL_CMD
@ IDEAL_CMD
Definition grammar.cc:285
MATRIX_CMD
@ MATRIX_CMD
Definition grammar.cc:287
INTMAT_CMD
@ INTMAT_CMD
Definition grammar.cc:280
MODUL_CMD
@ MODUL_CMD
Definition grammar.cc:288
VECTOR_CMD
@ VECTOR_CMD
Definition grammar.cc:293
NUMBER_CMD
@ NUMBER_CMD
Definition grammar.cc:289
POLY_CMD
@ POLY_CMD
Definition grammar.cc:290
matrix
ip_smatrix * matrix
Definition matpol.h:43
lists
slists * lists
Definition mpr_numeric.h:146
NULL
#define NULL
Definition omList.c:12
LIST_CMD
@ LIST_CMD
Definition tok.h:118
INTVEC_CMD
@ INTVEC_CMD
Definition tok.h:101
INT_CMD
@ INT_CMD
Definition tok.h:96

## ii_CallLibProcM()

leftv ii_CallLibProcM | ( | const char * | n,
|  | void ** | args,
|  | int * | arg_types,
|  | const ring | R,
|  | BOOLEAN & | err )

args: NULL terminated array of arguments arg_types: 0 terminated array of corresponding types

Definition at line 710 of file iplib.cc.

{
idhdl h=ggetid(n);
if ((h==NULL)
|| (IDTYP(h)!=PROC_CMD))
{
err=2;
return NULL;
}
// ring handling
idhdl save_ringhdl=currRingHdl;
ring save_ring=currRing;
rChangeCurrRing(R);
iiCallLibProcBegin();
// argument:
if (arg_types[0]!=0)
{
sleftv tmp;
leftv tt=&tmp;
int i=1;
tmp.Init();
tmp.data=args[0];
tmp.rtyp=arg_types[0];
while(arg_types[i]!=0)
{
tt->next=(leftv)omAlloc0Bin(sleftv_bin);
tt=tt->next;
tt->rtyp=arg_types[i];
tt->data=args[i];
i++;
}
// call proc
err=iiMake_proc(h,currPack,&tmp);
}
else
// call proc
err=iiMake_proc(h,currPack,NULL);
// clean up ring
iiCallLibProcEnd(save_ringhdl,save_ring);
// return
if (err==FALSE)
{
leftv h=(leftv)omAllocBin(sleftv_bin);
memcpy(h,&iiRETURNEXPR,sizeof(sleftv));
iiRETURNEXPR.Init();
return h;
}
return NULL;
}
FALSE
#define FALSE
Definition auxiliary.h:97
i
int i
Definition cfEzgcd.cc:132
sleftv
Class used for (list of) interpreter objects.
Definition subexpr.h:83
sleftv::rtyp
int rtyp
Definition subexpr.h:91
sleftv::Init
void Init()
Definition subexpr.h:107
sleftv::next
leftv next
Definition subexpr.h:86
sleftv::data
void * data
Definition subexpr.h:88
PROC_CMD
@ PROC_CMD
Definition grammar.cc:281
ggetid
idhdl ggetid(const char *n)
Definition ipid.cc:581
currRingHdl
VAR idhdl currRingHdl
Definition ipid.cc:57
currPack
VAR package currPack
Definition ipid.cc:55
sleftv_bin
EXTERN_VAR omBin sleftv_bin
Definition ipid.h:145
IDTYP
#define IDTYP(a)
Definition ipid.h:119
iiCallLibProcEnd
static void iiCallLibProcEnd(idhdl save_ringhdl, ring save_ring)
Definition iplib.cc:615
iiMake_proc
BOOLEAN iiMake_proc(idhdl pn, package pack, leftv args)
Definition iplib.cc:513
iiRETURNEXPR
INST_VAR sleftv iiRETURNEXPR
Definition iplib.cc:483
iiCallLibProcBegin
static void iiCallLibProcBegin()
Definition iplib.cc:598
h
STATIC_VAR Poly * h
Definition janet.cc:971
omAllocBin
#define omAllocBin(bin)
Definition omAllocDecl.h:205
omAlloc0Bin
#define omAlloc0Bin(bin)
Definition omAllocDecl.h:206
rChangeCurrRing
void rChangeCurrRing(ring r)
Definition polys.cc:16
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
idhdl
idrec * idhdl
Definition ring.h:22
R
#define R
Definition sirandom.c:27
leftv
sleftv * leftv
Definition structs.h:53

## ii_CallProcId2Id()

ideal ii_CallProcId2Id | ( | const char * | lib,
|  | const char * | proc,
|  | ideal | arg,
|  | const ring | R )

Definition at line 670 of file iplib.cc.

{
char *plib = iiConvName(lib);
idhdl h=ggetid(plib);
omFreeBinAddr(plib);
if (h==NULL)
{
BOOLEAN bo=iiLibCmd(lib,TRUE,TRUE,FALSE);
if (bo) return NULL;
}
ring oldR=currRing;
rChangeCurrRing(R);
BOOLEAN err;
ideal I=(ideal)iiCallLibProc1(proc,idCopy(arg),IDEAL_CMD,err);
rChangeCurrRing(oldR);
if (err) return NULL;
return I;
}
BOOLEAN
int BOOLEAN
Definition auxiliary.h:88
TRUE
#define TRUE
Definition auxiliary.h:101
proc
unsigned char * proc[NUM_PROC]
Definition checklibs.c:16
idCopy
ideal idCopy(ideal A)
Definition ideals.h:60
iiConvName
char * iiConvName(const char *libname)
Definition iplib.cc:1439
iiLibCmd
BOOLEAN iiLibCmd(const char *newlib, BOOLEAN autoexport, BOOLEAN tellerror, BOOLEAN force)
Definition iplib.cc:894
iiCallLibProc1
void * iiCallLibProc1(const char *n, void *arg, int arg_type, BOOLEAN &err)
Definition iplib.cc:636
omFreeBinAddr
#define omFreeBinAddr(addr)
Definition omAllocDecl.h:258

## ii_CallProcId2Int()

int ii_CallProcId2Int | ( | const char * | lib,
|  | const char * | proc,
|  | ideal | arg,
|  | const ring | R )

Definition at line 689 of file iplib.cc.

{
char *plib = iiConvName(lib);
idhdl h=ggetid(plib);
omFreeBinAddr(plib);
if (h==NULL)
{
BOOLEAN bo=iiLibCmd(lib,TRUE,TRUE,FALSE);
if (bo) return 0;
}
BOOLEAN err;
ring oldR=currRing;
rChangeCurrRing(R);
int I=(int)(long)iiCallLibProc1(proc,idCopy(arg),IDEAL_CMD,err);
rChangeCurrRing(oldR);
if (err) return 0;
return I;
}

## iiAddCproc()

int iiAddCproc | ( | const char * | libname,
|  | const char * | procname,
|  | BOOLEAN | pstatic,
|  | BOOLEAN(* | func )(leftv res, leftv v) )

Definition at line 1073 of file iplib.cc.

{
procinfov pi;
idhdl h;
#ifndef SING_NDEBUG
int dummy;
if (IsCmd(procname,dummy))
{
Werror(">>%s< is a reserved name",procname);
return 0;
}
#endif
h=IDROOT->get(procname,0);
if ((h!=NULL)
&& (IDTYP(h)==PROC_CMD))
{
pi = IDPROC(h);
#if 0
if ((pi->language == LANG_SINGULAR)
&&(BVERBOSE(V_REDEFINE)))
Warn("extend `%s`",procname);
#endif
}
else
{
h = enterid(procname,0, PROC_CMD, &IDROOT, TRUE);
}
if ( h!= NULL )
{
pi = IDPROC(h);
if((pi->language == LANG_SINGULAR)
||(pi->language == LANG_NONE))
{
omfree(pi->libname);
pi->libname = omStrDup(libname);
omfree(pi->procname);
pi->procname = omStrDup(procname);
pi->language = LANG_C;
pi->ref = 1;
pi->is_static = pstatic;
pi->data.o.function = func;
}
else if(pi->language == LANG_C)
{
if(pi->data.o.function == func)
{
pi->ref++;
}
else
{
omfree(pi->libname);
pi->libname = omStrDup(libname);
omfree(pi->procname);
pi->procname = omStrDup(procname);
pi->language = LANG_C;
pi->ref = 1;
pi->is_static = pstatic;
pi->data.o.function = func;
}
}
else
Warn("internal error: unknown procedure type %d",pi->language);
if (currPack->language==LANG_SINGULAR) currPack->language=LANG_MIX;
return(1);
}
else
{
WarnS("iiAddCproc: failed.");
}
return(0);
}
Warn
#define Warn
Definition emacs.cc:77
WarnS
#define WarnS
Definition emacs.cc:78
IsCmd
int IsCmd(const char *n, int &tok)
Definition iparith.cc:9773
enterid
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition ipid.cc:279
IDPROC
#define IDPROC(a)
Definition ipid.h:140
IDROOT
#define IDROOT
Definition ipid.h:19
pi
#define pi
Definition libparse.cc:1145
omStrDup
#define omStrDup(s)
Definition omAllocDecl.h:263
omfree
#define omfree(addr)
Definition omAllocDecl.h:237
BVERBOSE
#define BVERBOSE(a)
Definition options.h:35
V_REDEFINE
#define V_REDEFINE
Definition options.h:45
Werror
void Werror(const char *fmt,...)
Definition reporter.cc:189
procinfov
procinfo * procinfov
Definition structs.h:56
LANG_SINGULAR
@ LANG_SINGULAR
Definition subexpr.h:22
LANG_NONE
@ LANG_NONE
Definition subexpr.h:22
LANG_MIX
@ LANG_MIX
Definition subexpr.h:22
LANG_C
@ LANG_C
Definition subexpr.h:22

## iiAlias()

BOOLEAN iiAlias | ( | leftv | p | ) |

Definition at line 841 of file ipid.cc.

{
if (iiCurrArgs==NULL)
{
Werror("not enough arguments for proc %s",VoiceName());
p->CleanUp();
return TRUE;
}
leftv h=iiCurrArgs;
iiCurrArgs=h->next;
h->next=NULL;
if (h->rtyp!=IDHDL)
{
BOOLEAN res=iiAssign(p,h);
h->CleanUp();
omFreeBin((ADDRESS)h, sleftv_bin);
return res;
}
if ((h->Typ()!=p->Typ()) &&(p->Typ()!=DEF_CMD))
{
WerrorS("type mismatch");
return TRUE;
}
idhdl pp=(idhdl)p->data;
switch(pp->typ)
{
case CRING_CMD:
nKillChar((coeffs)pp);
break;
case DEF_CMD:
case INT_CMD:
break;
case INTVEC_CMD:
case INTMAT_CMD:
delete IDINTVEC(pp);
break;
case NUMBER_CMD:
nDelete(&IDNUMBER(pp));
break;
case BIGINT_CMD:
n_Delete(&IDNUMBER(pp),coeffs_BIGINT);
break;
case MAP_CMD:
{
map im = IDMAP(pp);
omFreeBinAddr((ADDRESS)im->preimage);
im->preimage=NULL;// and continue
}
// continue as ideal:
case IDEAL_CMD:
case MODUL_CMD:
case MATRIX_CMD:
idDelete(&IDIDEAL(pp));
break;
case PROC_CMD:
case RESOLUTION_CMD:
case STRING_CMD:
omFree((ADDRESS)IDSTRING(pp));
break;
case LIST_CMD:
IDLIST(pp)->Clean();
break;
case LINK_CMD:
omFreeBin(IDLINK(pp),sip_link_bin);
break;
// case ring: cannot happen
default:
{
int t=p->Typ();
if (t<MAX_TOK)
{
Werror("unknown type %d(%s)",t,Tok2Cmdname(t));
return TRUE;
}
/*else: blackbox type, not yet set*/
break;
}
}
pp->typ=ALIAS_CMD;
IDDATA(pp)=(char*)h->data;
int eff_typ=h->Typ();
if ((RingDependend(eff_typ))
|| ((eff_typ==LIST_CMD) && (lRingDependend((lists)h->Data()))))
{
ipSwapId(pp,IDROOT,currRing->idroot);
}
h->CleanUp();
omFreeBin((ADDRESS)h, sleftv_bin);
return FALSE;
}
ADDRESS
void * ADDRESS
Definition auxiliary.h:120
pp
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f ).
Definition cf_gcd.cc:676
p
int p
Definition cfModGcd.cc:4086
map
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
Definition cf_map_ext.cc:505
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:461
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition numbers.cc:563
res
CanonicalForm res
Definition facAbsFact.cc:60
WerrorS
void WerrorS(const char *s)
Definition feFopen.cc:24
VoiceName
const char * VoiceName()
Definition fevoices.cc:58
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition gentable.cc:137
RingDependend
static int RingDependend(int t)
Definition gentable.cc:23
MAP_CMD
@ MAP_CMD
Definition grammar.cc:286
RESOLUTION_CMD
@ RESOLUTION_CMD
Definition grammar.cc:291
idDelete
#define idDelete(H)
delete an ideal
Definition ideals.h:29
iiAssign
BOOLEAN iiAssign(leftv l, leftv r, BOOLEAN toplevel)
Definition ipassign.cc:2099
ipSwapId
static int ipSwapId(idhdl tomove, idhdl &root1, idhdl &root2)
Definition ipid.cc:679
IDMAP
#define IDMAP(a)
Definition ipid.h:135
IDSTRING
#define IDSTRING(a)
Definition ipid.h:136
IDDATA
#define IDDATA(a)
Definition ipid.h:126
IDINTVEC
#define IDINTVEC(a)
Definition ipid.h:128
IDLINK
#define IDLINK(a)
Definition ipid.h:138
IDIDEAL
#define IDIDEAL(a)
Definition ipid.h:133
IDNUMBER
#define IDNUMBER(a)
Definition ipid.h:132
IDLIST
#define IDLIST(a)
Definition ipid.h:137
iiCurrArgs
VAR leftv iiCurrArgs
Definition ipshell.cc:81
lRingDependend
BOOLEAN lRingDependend(lists L)
Definition lists.cc:222
coeffs
The main handler for Singular numbers which are suitable for Singular polynomials.
nDelete
#define nDelete(n)
Definition numbers.h:16
omFree
#define omFree(addr)
Definition omAllocDecl.h:261
omFreeBin
#define omFreeBin(addr, bin)
Definition omAllocDecl.h:259
coeffs_BIGINT
VAR coeffs coeffs_BIGINT
Definition polys.cc:14
sip_link_bin
VAR omBin sip_link_bin
Definition silink.cc:40
IDHDL
#define IDHDL
Definition tok.h:31
ALIAS_CMD
@ ALIAS_CMD
Definition tok.h:34
BIGINT_CMD
@ BIGINT_CMD
Definition tok.h:38
CRING_CMD
@ CRING_CMD
Definition tok.h:56
DEF_CMD
@ DEF_CMD
Definition tok.h:58
LINK_CMD
@ LINK_CMD
Definition tok.h:117
STRING_CMD
@ STRING_CMD
Definition tok.h:187
MAX_TOK
@ MAX_TOK
Definition tok.h:220

## iiAllStart()

BOOLEAN iiAllStart | ( | procinfov | pi,
|  | const char * | p,
|  | feBufferTypes | t,
|  | int | l )

Definition at line 306 of file iplib.cc.

{
int save_trace=traceit;
int restore_traceit=0;
if (traceit_stop
&& (traceit & TRACE_SHOW_LINE))
{
traceit &=(~TRACE_SHOW_LINE);
traceit_stop=0;
restore_traceit=1;
}
// see below:
BITSET save1=si_opt_1;
BITSET save2=si_opt_2;
newBuffer( omStrDup(p /*pi->data.s.body*/), t /*BT_proc*/,
pi, l );
BOOLEAN err=yyparse();
if (sLastPrinted.rtyp!=0)
{
sLastPrinted.CleanUp();
}
if (restore_traceit) traceit=save_trace;
// the access to optionStruct and verboseStruct do not work
// on x86_64-Linux for pic-code
if ((TEST_V_ALLWARN) &&
(t==BT_proc) &&
((save1!=si_opt_1)||(save2!=si_opt_2)) &&
(pi->libname!=NULL) && (pi->libname[0]!='\0'))
{
if ((pi->libname!=NULL) && (pi->libname[0]!='\0'))
Warn("option changed in proc %s from %s",pi->procname,pi->libname);
else
Warn("option changed in proc %s",pi->procname);
int i;
for (i=0; optionStruct[i].setval!=0; i++)
{
if ((optionStruct[i].setval & si_opt_1)
&& (!(optionStruct[i].setval & save1)))
{
Print(" +%s",optionStruct[i].name);
}
if (!(optionStruct[i].setval & si_opt_1)
&& ((optionStruct[i].setval & save1)))
{
Print(" -%s",optionStruct[i].name);
}
}
for (i=0; verboseStruct[i].setval!=0; i++)
{
if ((verboseStruct[i].setval & si_opt_2)
&& (!(verboseStruct[i].setval & save2)))
{
Print(" +%s",verboseStruct[i].name);
}
if (!(verboseStruct[i].setval & si_opt_2)
&& ((verboseStruct[i].setval & save2)))
{
Print(" -%s",verboseStruct[i].name);
}
}
PrintLn();
}
return err;
}
BITSET
#define BITSET
Definition auxiliary.h:85
l
int l
Definition cfEzgcd.cc:100
Print
#define Print
Definition emacs.cc:80
name
char name(const Variable &v)
Definition factory.h:189
newBuffer
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
Definition fevoices.cc:166
BT_proc
@ BT_proc
Definition fevoices.h:20
yyparse
int yyparse(void)
Definition grammar.cc:2149
verboseStruct
const struct soptionStruct verboseStruct[]
Definition misc_ip.cc:539
optionStruct
const struct soptionStruct optionStruct[]
Definition misc_ip.cc:508
si_opt_2
VAR unsigned si_opt_2
Definition options.c:6
si_opt_1
VAR unsigned si_opt_1
Definition options.c:5
TEST_V_ALLWARN
#define TEST_V_ALLWARN
Definition options.h:145
PrintLn
void PrintLn()
Definition reporter.cc:314
TRACE_SHOW_LINE
#define TRACE_SHOW_LINE
Definition reporter.h:33
traceit
EXTERN_VAR int traceit
Definition reporter.h:24
traceit_stop
EXTERN_VAR int traceit_stop
Definition reporter.h:25
sLastPrinted
INST_VAR sleftv sLastPrinted
Definition subexpr.cc:46

## iiApply()

BOOLEAN iiApply | ( | leftv | res,
|  | leftv | a,
|  | int | op,
|  | leftv | proc )

Definition at line 6431 of file ipshell.cc.

{
res->Init();
res->rtyp=a->Typ();
switch (res->rtyp /*a->Typ()*/)
{
case INTVEC_CMD:
case INTMAT_CMD:
return iiApplyINTVEC(res,a,op,proc);
case BIGINTMAT_CMD:
return iiApplyBIGINTMAT(res,a,op,proc);
case IDEAL_CMD:
case MODUL_CMD:
case MATRIX_CMD:
return iiApplyIDEAL(res,a,op,proc);
case LIST_CMD:
return iiApplyLIST(res,a,op,proc);
}
WerrorS("first argument to `apply` must allow an index");
return TRUE;
}
sleftv::Typ
int Typ()
Definition subexpr.cc:1048
BIGINTMAT_CMD
@ BIGINTMAT_CMD
Definition grammar.cc:278
iiApplyINTVEC
BOOLEAN iiApplyINTVEC(leftv res, leftv a, int op, leftv proc)
Definition ipshell.cc:6350
iiApplyLIST
BOOLEAN iiApplyLIST(leftv res, leftv a, int op, leftv proc)
Definition ipshell.cc:6392
iiApplyIDEAL
BOOLEAN iiApplyIDEAL(leftv, leftv, int, leftv)
Definition ipshell.cc:6387
iiApplyBIGINTMAT
BOOLEAN iiApplyBIGINTMAT(leftv, leftv, int, leftv)
Definition ipshell.cc:6382

## iiARROW()

BOOLEAN iiARROW | ( | leftv | r,
|  | char * | a,
|  | char * | s )

Definition at line 6480 of file ipshell.cc.

{
size_t len=strlen(a)+strlen(s)+30; /* max. 27 currently */
char *ss=(char*)omAlloc(len);
// find end of s:
int end_s=strlen(s);
while ((end_s>0) && ((s[end_s]<=' ')||(s[end_s]==';'))) end_s--;
s[end_s+1]='\0';
char *name=(char *)omAlloc(len);
snprintf(name,len,"%s->%s",a,s);
// find start of last expression
int start_s=end_s-1;
while ((start_s>=0) && (s[start_s]!=';')) start_s--;
if (start_s<0) // ';' not found
{
snprintf(ss,len,"parameter def %s;return(%s);\n",a,s);
}
else // s[start_s] is ';'
{
s[start_s]='\0';
snprintf(ss,len,"parameter def %s;%s;return(%s);\n",a,s,s+start_s+1);
}
r->Init();
// now produce procinfo for PROC_CMD:
r->data = (void *)omAlloc0Bin(procinfo_bin);
((procinfo *)(r->data))->language=LANG_NONE;
iiInitSingularProcinfo((procinfo *)r->data,"",name,0,0);
((procinfo *)r->data)->data.s.body=ss;
omFree(name);
r->rtyp=PROC_CMD;
//r->rtyp=STRING_CMD;
//r->data=ss;
return FALSE;
}
s
const CanonicalForm int s
Definition facAbsFact.cc:51
iiInitSingularProcinfo
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int, long pos, BOOLEAN pstatic)
Definition iplib.cc:1059
omAlloc
#define omAlloc(size)
Definition omAllocDecl.h:210
procinfo_bin
VAR omBin procinfo_bin
Definition subexpr.cc:42
procinfo
Definition subexpr.h:54

## iiAssign()

BOOLEAN iiAssign | ( | leftv | left,
|  | leftv | right,
|  | BOOLEAN | toplevel = TRUE )

Definition at line 2099 of file ipassign.cc.

{
if (errorreported) return TRUE;
int ll=l->listLength();
int rl;
int lt=l->Typ();
int rt=NONE;
int is_qring=FALSE;
BOOLEAN b=FALSE;
if (l->rtyp==ALIAS_CMD)
{
Werror("`%s` is read-only",l->Name());
}
if (l->rtyp==IDHDL)
{
atKillAll((idhdl)l->data);
is_qring=hasFlag((idhdl)l->data,FLAG_QRING_DEF);
IDFLAG((idhdl)l->data)=0;
l->attribute=NULL;
toplevel=FALSE;
}
else if (l->attribute!=NULL)
atKillAll((idhdl)l);
if (ll==1)
{
/* l[..] = ... */
if(l->e!=NULL)
{
BOOLEAN like_lists=0;
blackbox *bb=NULL;
int bt;
if (((bt=l->rtyp)>MAX_TOK)
|| ((l->rtyp==IDHDL) && ((bt=IDTYP((idhdl)l->data))>MAX_TOK)))
{
bb=getBlackboxStuff(bt);
like_lists=BB_LIKE_LIST(bb); // bb like a list
}
else if (((l->rtyp==IDHDL) && (IDTYP((idhdl)l->data)==LIST_CMD))
|| (l->rtyp==LIST_CMD))
{
like_lists=2; // bb in a list
}
if(like_lists)
{
if (traceit&TRACE_ASSIGN) PrintS("assign list[..]=...or similar\n");
if (like_lists==1)
{
// check blackbox/newtype type:
if(bb->blackbox_CheckAssign(bb,l,r)) return TRUE;
}
b=jiAssign_list(l,r);
if((!b) && (like_lists==2))
{
//Print("jjA_L_LIST: - 2 \n");
if((l->rtyp==IDHDL) && (l->data!=NULL))
{
ipMoveId((idhdl)l->data);
l->attribute=IDATTR((idhdl)l->data);
l->flag=IDFLAG((idhdl)l->data);
}
}
r->CleanUp();
Subexpr h;
while (l->e!=NULL)
{
h=l->e->next;
omFreeBin((ADDRESS)l->e, sSubexpr_bin);
l->e=h;
}
return b;
}
}
if (lt>MAX_TOK)
{
blackbox *bb=getBlackboxStuff(lt);
#ifdef BLACKBOX_DEVEL
Print("bb-assign: bb=%lx\n",bb);
#endif
return (bb==NULL) || bb->blackbox_Assign(l,r);
}
// end of handling elems of list and similar
rl=r->listLength();
if (rl==1)
{
/* system variables = ... */
if(((l->rtyp>=VECHO)&&(l->rtyp<=VPRINTLEVEL))
||((l->rtyp>=VALTVARS)&&(l->rtyp<=VMINPOLY)))
{
b=iiAssign_sys(l,r);
r->CleanUp();
//l->CleanUp();
return b;
}
rt=r->Typ();
/* a = ... */
if ((lt!=MATRIX_CMD)
&&(lt!=BIGINTMAT_CMD)
&&(lt!=BIGINTVEC_CMD)
&&(lt!=CMATRIX_CMD)
&&(lt!=INTMAT_CMD)
&&((lt==rt)||(lt!=LIST_CMD)))
{
b=jiAssign_1(l,r,rt,toplevel,is_qring);
if (l->rtyp==IDHDL)
{
if ((lt==DEF_CMD)||(lt==LIST_CMD))
{
ipMoveId((idhdl)l->data);
}
l->attribute=IDATTR((idhdl)l->data);
l->flag=IDFLAG((idhdl)l->data);
l->CleanUp();
}
r->CleanUp();
return b;
}
if (((lt!=LIST_CMD)
&&((rt==MATRIX_CMD)
||(rt==BIGINTMAT_CMD)
||(rt==BIGINTVEC_CMD)
||(rt==CMATRIX_CMD)
||(rt==INTMAT_CMD)
||(rt==INTVEC_CMD)
||(rt==MODUL_CMD)))
||((lt==LIST_CMD)
&&(rt==RESOLUTION_CMD))
)
{
b=jiAssign_1(l,r,rt,toplevel);
if((l->rtyp==IDHDL)&&(l->data!=NULL))
{
if ((lt==DEF_CMD) || (lt==LIST_CMD))
{
//Print("ipAssign - 3.0\n");
ipMoveId((idhdl)l->data);
}
l->attribute=IDATTR((idhdl)l->data);
l->flag=IDFLAG((idhdl)l->data);
}
r->CleanUp();
Subexpr h;
while (l->e!=NULL)
{
h=l->e->next;
omFreeBin((ADDRESS)l->e, sSubexpr_bin);
l->e=h;
}
return b;
}
}
if (rt==NONE) rt=r->Typ();
}
else if (ll==(rl=r->listLength()))
{
b=jiAssign_rec(l,r);
return b;
}
else
{
if (rt==NONE) rt=r->Typ();
if (rt==INTVEC_CMD)
return jiA_INTVEC_L(l,r);
else if (rt==VECTOR_CMD)
return jiA_VECTOR_L(l,r);
else if ((rt==IDEAL_CMD)||(rt==MATRIX_CMD))
return jiA_MATRIX_L(l,r);
else if ((rt==STRING_CMD)&&(rl==1))
return jiA_STRING_L(l,r);
Werror("length of lists in assignment does not match (l:%d,r:%d)",
ll,rl);
return TRUE;
}
leftv hh=r;
BOOLEAN map_assign=FALSE;
switch (lt)
{
case INTVEC_CMD:
b=jjA_L_INTVEC(l,r,new intvec(exprlist_length(r)));
break;
case INTMAT_CMD:
{
b=jjA_L_INTVEC(l,r,new intvec(IDINTVEC((idhdl)l->data)));
break;
}
case BIGINTVEC_CMD:
{
b=jjA_L_BIGINTVEC(l, r, new bigintmat(IDBIMAT((idhdl)l->data)));
break;
}
case BIGINTMAT_CMD:
{
b=jjA_L_BIGINTMAT(l, r, new bigintmat(IDBIMAT((idhdl)l->data)));
break;
}
case MAP_CMD:
{
// first element in the list sl (r) must be a ring
if ((rt == RING_CMD)&&(r->e==NULL))
{
omFreeBinAddr((ADDRESS)IDMAP((idhdl)l->data)->preimage);
IDMAP((idhdl)l->data)->preimage = omStrDup (r->Fullname());
/* advance the expressionlist to get the next element after the ring */
hh = r->next;
}
else
{
WerrorS("expected ring-name");
b=TRUE;
break;
}
if (hh==NULL) /* map-assign: map f=r; */
{
WerrorS("expected image ideal");
b=TRUE;
break;
}
if ((hh->next==NULL)&&(hh->Typ()==IDEAL_CMD))
{
b=jiAssign_1(l,hh,IDEAL_CMD,toplevel); /* map-assign: map f=r,i; */
omFreeBin(hh,sleftv_bin);
return b;
}
//no break, handle the rest like an ideal:
map_assign=TRUE; // and continue
}
case MATRIX_CMD:
case IDEAL_CMD:
case MODUL_CMD:
{
sleftv t;
matrix olm = (matrix)l->Data();
long rk;
char *pr=((map)olm)->preimage;
BOOLEAN module_assign=(/*l->Typ()*/ lt==MODUL_CMD);
matrix lm ;
long num;
int j,k;
int i=0;
int mtyp=MATRIX_CMD; /*Type of left side object*/
int etyp=POLY_CMD; /*Type of elements of left side object*/
if (lt /*l->Typ()*/==MATRIX_CMD)
{
rk=olm->rows();
num=olm->cols()*rk /*olm->rows()*/;
lm=mpNew(olm->rows(),olm->cols());
int el;
if ((traceit&TRACE_ASSIGN) && (num!=(el=exprlist_length(hh))))
{
Warn("expression list length(%d) does not match matrix size(%d)",el,num);
}
}
else /* IDEAL_CMD or MODUL_CMD */
{
num=exprlist_length(hh);
lm=(matrix)idInit(num,1);
if (module_assign)
{
rk=0;
mtyp=MODUL_CMD;
etyp=VECTOR_CMD;
}
else
rk=1;
}
int ht;
loop
{
if (hh==NULL)
break;
else
{
matrix rm;
ht=hh->Typ();
if ((j=iiTestConvert(ht,etyp))!=0)
{
b=iiConvert(ht,etyp,j,hh,&t);
hh->next=t.next;
if (b)
{ Werror("can not convert %s(%s) -> %s",Tok2Cmdname(ht),hh->Name(),Tok2Cmdname(etyp));
break;
}
lm->m[i]=(poly)t.CopyD(etyp);
pNormalize(lm->m[i]);
if (module_assign) rk=si_max(rk,pMaxComp(lm->m[i]));
i++;
}
else
if ((j=iiTestConvert(ht,mtyp))!=0)
{
b=iiConvert(ht,mtyp,j,hh,&t);
hh->next=t.next;
if (b)
{ Werror("can not convert %s(%s) -> %s",Tok2Cmdname(ht),hh->Name(),Tok2Cmdname(mtyp));
break;
}
rm = (matrix)t.CopyD(mtyp);
if (module_assign)
{
j = si_min((int)num,rm->cols());
rk=si_max(rk,rm->rank);
}
else
j = si_min(num-i,(long)rm->rows() * (long)rm->cols());
for(k=0;k<j;k++,i++)
{
lm->m[i]=rm->m[k];
pNormalize(lm->m[i]);
rm->m[k]=NULL;
}
idDelete((ideal *)&rm);
}
else
{
b=TRUE;
Werror("can not convert %s(%s) -> %s",Tok2Cmdname(ht),hh->Name(),Tok2Cmdname(mtyp));
break;
}
t.next=NULL;t.CleanUp();
if (i==num) break;
hh=hh->next;
}
}
if (b)
idDelete((ideal *)&lm);
else
{
idDelete((ideal *)&olm);
if (module_assign) lm->rank=rk;
else if (map_assign) ((map)lm)->preimage=pr;
l=l->LData();
if (l->rtyp==IDHDL)
IDMATRIX((idhdl)l->data)=lm;
else
l->data=(char *)lm;
}
break;
}
case STRING_CMD:
b=jjA_L_STRING(l,r);
break;
//case DEF_CMD:
case LIST_CMD:
b=jjA_L_LIST(l,r);
break;
case NONE:
case 0:
Werror("cannot assign to %s",l->Fullname());
b=TRUE;
break;
default:
WerrorS("assign not impl.");
b=TRUE;
break;
} /* end switch: typ */
if (b && (!errorreported)) WerrorS("incompatible type in list assignment");
r->CleanUp();
return b;
}
atKillAll
#define atKillAll(H)
Definition attrib.h:47
si_max
static int si_max(const int a, const int b)
Definition auxiliary.h:125
si_min
static int si_min(const int a, const int b)
Definition auxiliary.h:126
getBlackboxStuff
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition blackbox.cc:17
BB_LIKE_LIST
#define BB_LIKE_LIST(B)
Definition blackbox.h:53
num
CanonicalForm num(const CanonicalForm &f)
Definition canonicalform.h:337
k
int k
Definition cfEzgcd.cc:99
b
CanonicalForm b
Definition cfModGcd.cc:4111
bigintmat
Matrices of numbers.
Definition bigintmat.h:51
ip_smatrix::rank
long rank
Definition matpol.h:19
ip_smatrix::m
poly * m
Definition matpol.h:18
sleftv::CopyD
void * CopyD(int t)
Definition subexpr.cc:714
sleftv::Name
const char * Name()
Definition subexpr.h:120
sleftv::CleanUp
void CleanUp(ring r=currRing)
Definition subexpr.cc:351
j
int j
Definition facHensel.cc:110
errorreported
VAR short errorreported
Definition feFopen.cc:23
iiTestConvert
int iiTestConvert(int inputType, int outputType)
Definition gentable.cc:298
VALTVARS
@ VALTVARS
Definition grammar.cc:306
BIGINTVEC_CMD
@ BIGINTVEC_CMD
Definition grammar.cc:279
VMINPOLY
@ VMINPOLY
Definition grammar.cc:310
RING_CMD
@ RING_CMD
Definition grammar.cc:282
jjA_L_BIGINTVEC
static BOOLEAN jjA_L_BIGINTVEC(leftv l, leftv r, bigintmat *bim)
Definition ipassign.cc:1819
jiA_MATRIX_L
static BOOLEAN jiA_MATRIX_L(leftv l, leftv r)
Definition ipassign.cc:1892
jiA_VECTOR_L
static BOOLEAN jiA_VECTOR_L(leftv l, leftv r)
Definition ipassign.cc:1615
iiAssign_sys
static BOOLEAN iiAssign_sys(leftv l, leftv r)
Definition ipassign.cc:1515
jiAssign_rec
static BOOLEAN jiAssign_rec(leftv l, leftv r)
Definition ipassign.cc:2076
jiAssign_1
static BOOLEAN jiAssign_1(leftv l, leftv r, int rt, BOOLEAN toplevel, BOOLEAN is_qring=FALSE)
Definition ipassign.cc:1332
jjA_L_LIST
static BOOLEAN jjA_L_LIST(leftv l, leftv r)
Definition ipassign.cc:1656
jiA_STRING_L
static BOOLEAN jiA_STRING_L(leftv l, leftv r)
Definition ipassign.cc:1968
jjA_L_BIGINTMAT
static BOOLEAN jjA_L_BIGINTMAT(leftv l, leftv r, bigintmat *bim)
Definition ipassign.cc:1770
jiAssign_list
static BOOLEAN jiAssign_list(leftv l, leftv r)
Definition ipassign.cc:2004
jjA_L_STRING
static BOOLEAN jjA_L_STRING(leftv l, leftv r)
Definition ipassign.cc:1858
jiA_INTVEC_L
static BOOLEAN jiA_INTVEC_L(leftv l, leftv r)
Definition ipassign.cc:1589
jjA_L_INTVEC
static BOOLEAN jjA_L_INTVEC(leftv l, leftv r, intvec *iv)
Definition ipassign.cc:1721
iiConvert
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
Definition ipconv.cc:450
ipMoveId
void ipMoveId(idhdl tomove)
Definition ipid.cc:704
IDMATRIX
#define IDMATRIX(a)
Definition ipid.h:134
hasFlag
#define hasFlag(A, F)
Definition ipid.h:112
IDBIMAT
#define IDBIMAT(a)
Definition ipid.h:129
IDFLAG
#define IDFLAG(a)
Definition ipid.h:120
FLAG_QRING_DEF
#define FLAG_QRING_DEF
Definition ipid.h:109
IDATTR
#define IDATTR(a)
Definition ipid.h:123
exprlist_length
int exprlist_length(leftv v)
Definition ipshell.cc:551
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition matpol.cc:37
pMaxComp
#define pMaxComp(p)
Definition polys.h:300
pNormalize
#define pNormalize(p)
Definition polys.h:318
PrintS
void PrintS(const char *s)
Definition reporter.cc:288
TRACE_ASSIGN
#define TRACE_ASSIGN
Definition reporter.h:46
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition simpleideals.cc:35
loop
#define loop
Definition structs.h:71
sSubexpr_bin
VAR omBin sSubexpr_bin
Definition subexpr.cc:40
VPRINTLEVEL
@ VPRINTLEVEL
Definition tok.h:217
CMATRIX_CMD
@ CMATRIX_CMD
Definition tok.h:46
VECHO
@ VECHO
Definition tok.h:210
NONE
#define NONE
Definition tok.h:223

## iiAssignCR()

BOOLEAN iiAssignCR | ( | leftv | r,
|  | leftv | arg )

Definition at line 6515 of file ipshell.cc.

{
char* ring_name=omStrDup((char*)r->Name());
int t=arg->Typ();
if (t==RING_CMD)
{
sleftv tmp;
tmp.Init();
tmp.rtyp=IDHDL;
idhdl h=enterid(ring_name, myynest, RING_CMD, &IDROOT);
IDRING(h)=NULL;
tmp.data=(char*)h;
if (h!=NULL)
{
tmp.name=h->id;
BOOLEAN b=iiAssign(&tmp,arg);
if (b) return TRUE;
rSetHdl(ggetid(ring_name));
omFree(ring_name);
return FALSE;
}
else
return TRUE;
}
else if (t==CRING_CMD)
{
sleftv tmp;
sleftv n;
n.Init();
n.name=ring_name;
if (iiDeclCommand(&tmp,&n,myynest,CRING_CMD,&IDROOT)) return TRUE;
if (iiAssign(&tmp,arg)) return TRUE;
//Print("create %s\n",r->Name());
//Print("from %s(%d)\n",Tok2Cmdname(arg->Typ()),arg->Typ());
return FALSE;
}
//Print("create %s\n",r->Name());
//Print("from %s(%d)\n",Tok2Cmdname(arg->Typ()),arg->Typ());
return TRUE;// not handled -> error for now
}
sleftv::name
const char * name
Definition subexpr.h:87
myynest
VAR int myynest
Definition febase.cc:41
IDRING
#define IDRING(a)
Definition ipid.h:127
iiDeclCommand
int iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring, BOOLEAN init_b)
Definition ipshell.cc:1206
rSetHdl
void rSetHdl(idhdl h)
Definition ipshell.cc:5129

## iiBranchTo()

BOOLEAN iiBranchTo | ( | leftv | r,
|  | leftv | args )

Definition at line 1281 of file ipshell.cc.

{
// must be inside a proc, as we simultae an proc_end at the end
if (myynest==0)
{
WerrorS("branchTo can only occur in a proc");
return TRUE;
}
// <string1...stringN>,<proc>
// known: args!=NULL, l>=1
int l=args->listLength();
int ll=0;
if (iiCurrArgs!=NULL) ll=iiCurrArgs->listLength();
if (ll!=(l-1)) return FALSE;
leftv h=args;
// set up the table for type test:
short *t=(short*)omAlloc(l*sizeof(short));
t[0]=l-1;
int b;
int i;
for(i=1;i<l;i++,h=h->next)
{
if (h->Typ()!=STRING_CMD)
{
omFreeBinAddr(t);
Werror("arg %d is not a string",i);
return TRUE;
}
int tt;
b=IsCmd((char *)h->Data(),tt);
if(b) t[i]=tt;
else
{
omFreeBinAddr(t);
Werror("arg %d is not a type name",i);
return TRUE;
}
}
if (h->Typ()!=PROC_CMD)
{
omFreeBinAddr(t);
Werror("last(%d.) arg.(%s) is not a proc(but %s(%d)), nesting=%d",
i,h->name,Tok2Cmdname(h->Typ()),h->Typ(),myynest);
return TRUE;
}
b=iiCheckTypes(iiCurrArgs,t,0);
omFreeBinAddr(t);
if (b && (h->rtyp==IDHDL) && (h->e==NULL))
{
// get the proc:
iiCurrProc=(idhdl)h->data;
idhdl currProc=iiCurrProc; /*iiCurrProc may be changed after yyparse*/
procinfo * pi=IDPROC(currProc);
// already loaded ?
if( pi->data.s.body==NULL )
{
iiGetLibProcBuffer(pi);
if (pi->data.s.body==NULL) return TRUE;
}
// set currPackHdl/currPack
if ((pi->pack!=NULL)&&(currPack!=pi->pack))
{
currPack=pi->pack;
iiCheckPack(currPack);
currPackHdl=packFindHdl(currPack);
//Print("set pack=%s\n",IDID(currPackHdl));
}
// see iiAllStart:
BITSET save1=si_opt_1;
BITSET save2=si_opt_2;
newBuffer( omStrDup(pi->data.s.body), BT_proc,
pi, pi->data.s.body_lineno-(iiCurrArgs==NULL) );
BOOLEAN err=yyparse();
iiCurrProc=NULL;
si_opt_1=save1;
si_opt_2=save2;
// now save the return-expr.
sLastPrinted.CleanUp(currRing);
memcpy(&sLastPrinted,&iiRETURNEXPR,sizeof(sleftv));
iiRETURNEXPR.Init();
// warning about args.:
if (iiCurrArgs!=NULL)
{
if (err==0) Warn("too many arguments for %s",IDID(currProc));
iiCurrArgs->CleanUp();
omFreeBin((ADDRESS)iiCurrArgs, sleftv_bin);
iiCurrArgs=NULL;
}
// similate proc_end:
// - leave input
void myychangebuffer();
myychangebuffer();
// - set the current buffer to its end (this is a pointer in a buffer,
// not a file ptr) "branchTo" is only valid in proc)
currentVoice->fptr=strlen(currentVoice->buffer);
// - kill local vars
killlocals(myynest);
// - return
newBuffer(omStrDup("\n;return(_);\n"),BT_execute);
return (err!=0);
}
return FALSE;
}
sleftv::listLength
int listLength()
Definition subexpr.cc:51
currentVoice
VAR Voice * currentVoice
Definition fevoices.cc:49
BT_execute
@ BT_execute
Definition fevoices.h:23
currPackHdl
VAR idhdl currPackHdl
Definition ipid.cc:53
packFindHdl
idhdl packFindHdl(package r)
Definition ipid.cc:828
IDID
#define IDID(a)
Definition ipid.h:122
iiGetLibProcBuffer
char * iiGetLibProcBuffer(procinfo *pi, int part)
Definition iplib.cc:197
iiCurrProc
VAR idhdl iiCurrProc
Definition ipshell.cc:82
iiCheckPack
void iiCheckPack(package &p)
Definition ipshell.cc:1631
iiCheckTypes
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition ipshell.cc:6576
killlocals
void killlocals(int v)
Definition ipshell.cc:387
myychangebuffer
void myychangebuffer()
Definition scanner.cc:2311

## iiCallLibProc1()

void * iiCallLibProc1 | ( | const char * | n,
|  | void * | arg,
|  | int | arg_type,
|  | BOOLEAN & | err )

Definition at line 636 of file iplib.cc.

{
idhdl h=ggetid(n);
if ((h==NULL)
|| (IDTYP(h)!=PROC_CMD))
{
err=2;
return NULL;
}
// ring handling
idhdl save_ringhdl=currRingHdl;
ring save_ring=currRing;
iiCallLibProcBegin();
// argument:
sleftv tmp;
tmp.Init();
tmp.data=arg;
tmp.rtyp=arg_type;
// call proc
err=iiMake_proc(h,currPack,&tmp);
// clean up ring
iiCallLibProcEnd(save_ringhdl,save_ring);
// return
if (err==FALSE)
{
void*r=iiRETURNEXPR.data;
iiRETURNEXPR.data=NULL;
iiRETURNEXPR.CleanUp();
return r;
}
return NULL;
}

## iiCheckPack()

void iiCheckPack | ( | package & | p | ) |

Definition at line 1631 of file ipshell.cc.

{
if (p!=basePack)
{
idhdl t=basePack->idroot;
while ((t!=NULL) && (IDTYP(t)!=PACKAGE_CMD) && (IDPACKAGE(t)!=p)) t=t->next;
if (t==NULL)
{
WarnS("package not found\n");
p=basePack;
}
}
}
idrec::next
idhdl next
Definition idrec.h:38
basePack
VAR package basePack
Definition ipid.cc:56
IDPACKAGE
#define IDPACKAGE(a)
Definition ipid.h:139
PACKAGE_CMD
@ PACKAGE_CMD
Definition tok.h:150

## iiCheckRing()

BOOLEAN iiCheckRing | ( | int | i | ) |

Definition at line 1585 of file ipshell.cc.

{
if (currRing==NULL)
{
#ifdef SIQ
if (siq<=0)
{
#endif
if (RingDependend(i))
{
WerrorS("no ring active (9)");
return TRUE;
}
#ifdef SIQ
}
#endif
}
return FALSE;
}
siq
VAR BOOLEAN siq
Definition subexpr.cc:48

## iiCheckTypes()

BOOLEAN iiCheckTypes | ( | leftv | args,
|  | const short * | type_list,
|  | int | report = 0 )

check a list of arguemys against a given field of types return TRUE if the types match return FALSE (and, if report) report an error via Werror otherwise

Parameters

  type_list | < [in] argument list (may be NULL) [in] field of types len, t1,t2,...
  report | ;in] report error?

Definition at line 6576 of file ipshell.cc.

{
int l=0;
if (args==NULL)
{
if (type_list[0]==0) return TRUE;
}
else l=args->listLength();
if (l!=(int)type_list[0])
{
if (report) iiReportTypes(0,l,type_list);
return FALSE;
}
for(int i=1;i<=l;i++,args=args->next)
{
short t=type_list[i];
if (t!=ANY_TYPE)
{
if (((t==IDHDL)&&(args->rtyp!=IDHDL))
|| (t!=args->Typ()))
{
if (report) iiReportTypes(i,args->Typ(),type_list);
return FALSE;
}
}
}
return TRUE;
}
iiReportTypes
static void iiReportTypes(int nr, int t, const short *T)
Definition ipshell.cc:6556
ANY_TYPE
#define ANY_TYPE
Definition tok.h:30

## iiConvName()

char * iiConvName | ( | const char * | libname | ) |

Definition at line 1439 of file iplib.cc.

{
char *tmpname = omStrDup(libname);
char *p = strrchr(tmpname, DIR_SEP);
char *r;
if(p==NULL) p = tmpname; else p++;
// p is now the start of the file name (without path)
r=p;
while(isalnum(*r)||(*r=='_')) r++;
// r point the the end of the main part of the filename
*r = '\0';
r = omStrDup(p);
*r = mytoupper(*r);
// printf("iiConvName: '%s' '%s' => '%s'\n", libname, tmpname, r);
omFree((ADDRESS)tmpname);
return(r);
}
DIR_SEP
#define DIR_SEP
Definition feResource.h:6
mytoupper
static char mytoupper(char c)
Definition iplib.cc:1420

## iiDebug()

void iiDebug | ( |  | ) |

Definition at line 1073 of file ipshell.cc.

{
#ifdef HAVE_SDB
sdb_flags=1;
#endif
Print("\n-- break point in %s --\n",VoiceName());
if (iiDebugMarker) VoiceBackTrack();
char * s;
iiDebugMarker=FALSE;
s = (char *)omAlloc(BREAK_LINE_LENGTH+4);
loop
{
memset(s,0,BREAK_LINE_LENGTH+4);
fe_fgets_stdin("",s,BREAK_LINE_LENGTH);
if (s[BREAK_LINE_LENGTH-1]!='\0')
{
Print("line too long, max is %d chars\n",BREAK_LINE_LENGTH);
}
else
break;
}
if (*s=='\n')
{
iiDebugMarker=TRUE;
}
#if MDEBUG
else if(strncmp(s,"cont;",5)==0)
{
iiDebugMarker=TRUE;
}
#endif /* MDEBUG */
else
{
strcat( s, "\n;~\n");
newBuffer(s,BT_execute);
}
}
fe_fgets_stdin
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition feread.cc:32
VoiceBackTrack
void VoiceBackTrack()
Definition fevoices.cc:77
iiDebugMarker
VAR BOOLEAN iiDebugMarker
Definition ipshell.cc:1071
BREAK_LINE_LENGTH
#define BREAK_LINE_LENGTH
Definition ipshell.cc:1072
sdb_flags
VAR int sdb_flags
Definition sdb.cc:31

## iiDeclCommand()

int iiDeclCommand | ( | leftv | sy,
|  | leftv | name,
|  | int | lev,
|  | int | t,
|  | idhdl * | root,
|  | BOOLEAN | isring = FALSE,
|  | BOOLEAN | init_b = TRUE )

Definition at line 1206 of file ipshell.cc.

{
BOOLEAN res=FALSE;
BOOLEAN is_qring=FALSE;
const char *id = name->name;
sy->Init();
if ((name->name==NULL)||(isdigit(name->name[0])))
{
WerrorS("object to declare is not a name");
res=TRUE;
}
else
{
if (root==NULL) return TRUE;
if (*root!=IDROOT)
{
if ((currRing==NULL) || (*root!=currRing->idroot))
{
Werror("can not define `%s` in other package",name->name);
return TRUE;
}
}
if (t==QRING_CMD)
{
t=RING_CMD; // qring is always RING_CMD
is_qring=TRUE;
}
if (TEST_V_ALLWARN
&& (name->rtyp!=0)
&& (name->rtyp!=IDHDL)
&& (currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
{
Warn("`%s` is %s in %s:%d:%s",name->name,Tok2Cmdname(name->rtyp),
currentVoice->filename,yylineno,my_yylinebuf);
}
{
sy->data = (char *)enterid(id,lev,t,root,init_b);
}
if (sy->data!=NULL)
{
sy->rtyp=IDHDL;
currid=sy->name=IDID((idhdl)sy->data);
if (is_qring)
{
IDFLAG((idhdl)sy->data)=sy->flag=Sy_bit(FLAG_QRING_DEF);
}
// name->name=NULL; /* used in enterid */
//sy->e = NULL;
if (name->next!=NULL)
{
sy->next=(leftv)omAllocBin(sleftv_bin);
res=iiDeclCommand(sy->next,name->next,lev,t,root, isring);
}
}
else res=TRUE;
}
name->CleanUp();
return res;
}
sleftv::flag
BITSET flag
Definition subexpr.h:90
yylineno
VAR int yylineno
Definition febase.cc:40
my_yylinebuf
VAR char my_yylinebuf[80]
Definition febase.cc:44
currid
const char * currid
Definition grammar.cc:171
IDLEV
#define IDLEV(a)
Definition ipid.h:121
Sy_bit
#define Sy_bit(x)
Definition options.h:31
QRING_CMD
@ QRING_CMD
Definition tok.h:160

## iiEStart()

BOOLEAN iiEStart | ( | char * | example,
|  | procinfo * | pi )

Definition at line 763 of file iplib.cc.

{
BOOLEAN err;
int old_echo=si_echo;
iiCheckNest();
procstack->push(example);
iiLocalRing[myynest]=currRing;
if (traceit&TRACE_SHOW_PROC)
{
if (traceit&TRACE_SHOW_LINENO) printf("\n");
printf("entering example (level %d)\n",myynest);
}
myynest++;
err=iiAllStart(pi,example,BT_example,(pi != NULL ? pi->data.s.example_lineno: 0));
killlocals(myynest);
myynest--;
si_echo=old_echo;
if (traceit&TRACE_SHOW_PROC)
{
if (traceit&TRACE_SHOW_LINENO) printf("\n");
printf("leaving -example- (level %d)\n",myynest);
}
if (iiLocalRing[myynest] != currRing)
{
if (iiLocalRing[myynest]!=NULL)
{
rSetHdl(rFindHdl(iiLocalRing[myynest],NULL));
iiLocalRing[myynest]=NULL;
}
else
{
currRingHdl=NULL;
currRing=NULL;
}
}
procstack->pop();
return err;
}
si_echo
VAR int si_echo
Definition febase.cc:35
BT_example
@ BT_example
Definition fevoices.h:21
procstack
VAR proclevel * procstack
Definition ipid.cc:50
iiCheckNest
static void iiCheckNest()
Definition iplib.cc:502
iiLocalRing
VAR ring * iiLocalRing
Definition iplib.cc:482
iiAllStart
BOOLEAN iiAllStart(procinfov pi, const char *p, feBufferTypes t, int l)
Definition iplib.cc:306
rFindHdl
idhdl rFindHdl(ring r, idhdl n)
Definition ipshell.cc:1701
TRACE_SHOW_LINENO
#define TRACE_SHOW_LINENO
Definition reporter.h:31
TRACE_SHOW_PROC
#define TRACE_SHOW_PROC
Definition reporter.h:29

## iiExport() [1/2]

BOOLEAN iiExport | ( | leftv | v,
|  | int | toLev )

Definition at line 1510 of file ipshell.cc.

{
BOOLEAN nok=FALSE;
leftv r=v;
while (v!=NULL)
{
if ((v->name==NULL)||(v->rtyp==0)||(v->e!=NULL))
{
Werror("cannot export:%s of internal type %d",v->name,v->rtyp);
nok=TRUE;
}
else
{
if(iiInternalExport(v, toLev))
nok=TRUE;
}
v=v->next;
}
r->CleanUp();
return nok;
}
iiInternalExport
static BOOLEAN iiInternalExport(leftv v, int toLev)
Definition ipshell.cc:1411

## iiExport() [2/2]

BOOLEAN iiExport | ( | leftv | v,
|  | int | toLev,
|  | package | pack )

Definition at line 1533 of file ipshell.cc.

{
// if ((pack==basePack)&&(pack!=currPack))
// { Warn("'exportto' to Top is depreciated in >>%s<<",my_yylinebuf);}
BOOLEAN nok=FALSE;
leftv rv=v;
while (v!=NULL)
{
if ((v->name==NULL)||(v->rtyp==0)||(v->e!=NULL)
)
{
Werror("cannot export:%s of internal type %d",v->name,v->rtyp);
nok=TRUE;
}
else
{
idhdl old=pack->idroot->get( v->name,toLev);
if (old!=NULL)
{
if ((pack==currPack) && (old==(idhdl)v->data))
{
if (BVERBOSE(V_REDEFINE)) Warn("`%s` is already global",IDID(old));
break;
}
else if (IDTYP(old)==v->Typ())
{
if (BVERBOSE(V_REDEFINE))
{
Warn("redefining %s (%s)",IDID(old),my_yylinebuf);
}
v->name=omStrDup(v->name);
killhdl2(old,&(pack->idroot),currRing);
}
else
{
rv->CleanUp();
return TRUE;
}
}
//Print("iiExport: pack=%s\n",IDID(root));
if(iiInternalExport(v, toLev, pack))
{
rv->CleanUp();
return TRUE;
}
}
v=v->next;
}
rv->CleanUp();
return nok;
}
killhdl2
void killhdl2(idhdl h, idhdl *ih, ring r)
Definition ipid.cc:445

## iiExprArith1()

BOOLEAN iiExprArith1 | ( | leftv | res,
|  | sleftv * | a,
|  | int | op )

## iiExprArith1Tab()

BOOLEAN iiExprArith1Tab | ( | leftv | res,
|  | leftv | a,
|  | int | op,
|  | const struct sValCmd1 * | dA1,
|  | int | at,
|  | const struct sConvertTypes * | dConvertTypes )

apply an operation 'op' to an argument a return TRUE on failure

Parameters

  [out] | res | pre-allocated result
  [in] | a | argument
  [in] | op | operation
  [in] | dA1 | table of possible proc assumes dArith1[0].cmd==op
  [in] | at | a->Typ()
  [in] | dConvertTypes | table of type conversions

Definition at line 9235 of file iparith.cc.

{
res->Init();
BOOLEAN call_failed=FALSE;
if (!errorreported)
{
BOOLEAN failed=FALSE;
iiOp=op;
int i = 0;
while (dA1[i].cmd==op)
{
if (at==dA1[i].arg)
{
if (currRing!=NULL)
{
if (check_valid(dA1[i].valid_for,op)) break;
}
else
{
if (RingDependend(dA1[i].res))
{
WerrorS("no ring active (5)");
break;
}
}
if (traceit&TRACE_CALL)
Print("call %s(%s)\n",iiTwoOps(op),Tok2Cmdname(at));
res->rtyp=dA1[i].res;
if ((call_failed=dA1[i].p(res,a)))
{
break;// leave loop, goto error handling
}
if (a->Next()!=NULL)
{
res->next=(leftv)omAllocBin(sleftv_bin);
failed=iiExprArith1(res->next,a->next,op);
}
a->CleanUp();
return failed;
}
i++;
}
// implicite type conversion --------------------------------------------
if (dA1[i].cmd!=op)
{
leftv an = (leftv)omAlloc0Bin(sleftv_bin);
i=0;
//Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
while (dA1[i].cmd==op)
{
int ai;
//Print("test %s\n",Tok2Cmdname(dA1[i].arg));
if ((dA1[i].valid_for & NO_CONVERSION)==0)
{
if ((ai=iiTestConvert(at,dA1[i].arg,dConvertTypes))!=0)
{
if (currRing!=NULL)
{
if (check_valid(dA1[i].valid_for,op)) break;
}
else
{
if (RingDependend(dA1[i].res))
{
WerrorS("no ring active (6)");
break;
}
}
if (traceit&TRACE_CALL)
Print("call %s(%s)\n",iiTwoOps(op),Tok2Cmdname(dA1[i].arg));
res->rtyp=dA1[i].res;
failed= ((iiConvert(at,dA1[i].arg,ai,a,an,dConvertTypes))
|| (call_failed=dA1[i].p(res,an)));
// everything done, clean up temp. variables
if (failed)
{
// leave loop, goto error handling
break;
}
else
{
if (an->Next() != NULL)
{
res->next = (leftv)omAllocBin(sleftv_bin);
failed=iiExprArith1(res->next,an->next,op);
}
// everything ok, clean up and return
an->CleanUp();
omFreeBin((ADDRESS)an, sleftv_bin);
return failed;
}
}
}
i++;
}
an->CleanUp();
omFreeBin((ADDRESS)an, sleftv_bin);
}
// error handling
if (!errorreported)
{
if ((at==0) && (a->Fullname()!=sNoName_fe))
{
Werror("`%s` is not defined",a->Fullname());
}
else
{
i=0;
const char *s = iiTwoOps(op);
Werror("%s(`%s`) failed"
,s,Tok2Cmdname(at));
if ((!call_failed) && BVERBOSE(V_SHOW_USE))
{
while (dA1[i].cmd==op)
{
if ((dA1[i].res!=0)
&& (dA1[i].p!=jjWRONG))
Werror("expected %s(`%s`)"
,s,Tok2Cmdname(dA1[i].arg));
i++;
}
}
}
}
res->rtyp = UNKNOWN;
}
a->CleanUp();
return TRUE;
}
sleftv::Next
leftv Next()
Definition subexpr.h:136
sleftv::Fullname
const char * Fullname()
Definition subexpr.h:125
sNoName_fe
const char sNoName_fe[]
Definition fevoices.cc:57
NO_CONVERSION
#define NO_CONVERSION
Definition gentable.cc:51
iiTwoOps
const char * iiTwoOps(int t)
Definition gentable.cc:258
jjWRONG
#define jjWRONG
Definition gentable.cc:124
iiExprArith1
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
Definition iparith.cc:9365
check_valid
static BOOLEAN check_valid(const int p, const int op)
Definition iparith.cc:10177
iiOp
VAR int iiOp
Definition iparith.cc:219
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition iparith.cc:9897
dConvertTypes
const struct sConvertTypes dConvertTypes[]
Definition table.h:1321
sValCmd1::p
int p
Definition gentable.cc:77
sValCmd1::res
short res
Definition gentable.cc:79
V_SHOW_USE
#define V_SHOW_USE
Definition options.h:52
TRACE_CALL
#define TRACE_CALL
Definition reporter.h:44
UNKNOWN
#define UNKNOWN
Definition tok.h:224

## iiExprArith2()

BOOLEAN iiExprArith2 | ( | leftv | res,
|  | sleftv * | a,
|  | int | op,
|  | sleftv * | b,
|  | BOOLEAN | proccall = FALSE )

## iiExprArith2Tab()

BOOLEAN iiExprArith2Tab | ( | leftv | res,
|  | leftv | a,
|  | int | op,
|  | const struct sValCmd2 * | dA2,
|  | int | at,
|  | const struct sConvertTypes * | dConvertTypes )

apply an operation 'op' to arguments a and a->next return TRUE on failure

Parameters

  [out] | res | pre-allocated result
  [in] | a | 2 arguments
  [in] | op | operation
  [in] | dA2 | table of possible proc assumes dA2[0].cmd==op
  [in] | at | a->Typ()
  [in] | dConvertTypes | table of type conversions

Definition at line 9162 of file iparith.cc.

{
res->Init();
leftv b=a->next;
a->next=NULL;
int bt=b->Typ();
BOOLEAN bo=iiExprArith2TabIntern(res,a,op,b,TRUE,dA2,at,bt,dConvertTypes);
a->next=b;
a->CleanUp(); // to clean up the chain, content already done in iiExprArith2TabIntern
return bo;
}
iiExprArith2TabIntern
static BOOLEAN iiExprArith2TabIntern(leftv res, leftv a, int op, leftv b, BOOLEAN proccall, const struct sValCmd2 *dA2, int at, int bt, const struct sConvertTypes *dConvertTypes)
Definition iparith.cc:9003

## iiExprArith3()

BOOLEAN iiExprArith3 | ( | leftv | res,
|  | int | op,
|  | leftv | a,
|  | leftv | b,
|  | leftv | c )

Definition at line 9575 of file iparith.cc.

{
res->Init();
if (!errorreported)
{
#ifdef SIQ
if (siq>0)
{
//Print("siq:%d\n",siq);
command d=(command)omAlloc0Bin(sip_command_bin);
memcpy(&d->arg1,a,sizeof(sleftv));
a->Init();
memcpy(&d->arg2,b,sizeof(sleftv));
b->Init();
memcpy(&d->arg3,c,sizeof(sleftv));
c->Init();
d->op=op;
d->argc=3;
res->data=(char *)d;
res->rtyp=COMMAND;
return FALSE;
}
#endif
int at=a->Typ();
// handling bb-objects ----------------------------------------------
if (at>MAX_TOK)
{
blackbox *bb=getBlackboxStuff(at);
if (bb!=NULL)
{
if(!bb->blackbox_Op3(op,res,a,b,c)) return FALSE;
// otherwise, try defaul (attrib,..)
}
else
return TRUE;
if (errorreported) return TRUE;
}
int bt=b->Typ();
int ct=c->Typ();
iiOp=op;
int i=0;
while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
return iiExprArith3TabIntern(res,op,a,b,c,dArith3+i,at,bt,ct,dConvertTypes);
}
a->CleanUp();
b->CleanUp();
c->CleanUp();
//Print("op: %d,result typ:%d\n",op,res->rtyp);
return TRUE;
}
iiExprArith3TabIntern
static BOOLEAN iiExprArith3TabIntern(leftv res, int op, leftv a, leftv b, leftv c, const struct sValCmd3 *dA3, int at, int bt, int ct, const struct sConvertTypes *dConvertTypes)
Definition iparith.cc:9422
sip_command_bin
VAR omBin sip_command_bin
Definition ipid.cc:45
command
ip_command * command
Definition ipid.h:23
dArith3
const struct sValCmd3 dArith3[]
Definition table.h:801
COMMAND
#define COMMAND
Definition tok.h:29

## iiExprArith3Tab()

BOOLEAN iiExprArith3Tab | ( | leftv | res,
|  | leftv | a,
|  | int | op,
|  | const struct sValCmd3 * | dA3,
|  | int | at,
|  | const struct sConvertTypes * | dConvertTypes )

apply an operation 'op' to arguments a, a->next and a->next->next return TRUE on failure

Parameters

  [out] | res | pre-allocated result
  [in] | a | 3 arguments
  [in] | op | operation
  [in] | dA3 | table of possible proc assumes dA3[0].cmd==op
  [in] | at | a->Typ()
  [in] | dConvertTypes | table of type conversions

Definition at line 9627 of file iparith.cc.

{
res->Init();
leftv b=a->next;
a->next=NULL;
int bt=b->Typ();
leftv c=b->next;
b->next=NULL;
int ct=c->Typ();
BOOLEAN bo=iiExprArith3TabIntern(res,op,a,b,c,dA3,at,bt,ct,dConvertTypes);
b->next=c;
a->next=b;
a->CleanUp(); // to cleanup the chain, content already done
return bo;
}

## iiExprArithM()

BOOLEAN iiExprArithM | ( | leftv | res,
|  | sleftv * | a,
|  | int | op )

## iiGetLibName()

char * iiGetLibName | ( | const procinfov | pi | ) |

inline static

find the library of an proc

Definition at line 66 of file ipshell.h.

{ return pi->libname; }

## iiGetLibProcBuffer()

char * iiGetLibProcBuffer | ( | procinfov | pi,
|  | int | part = 1 )

## iiGetLibStatus()

BOOLEAN iiGetLibStatus | ( | const char * | lib | ) |

Definition at line 77 of file iplib.cc.

{
idhdl hl;
char *plib = iiConvName(lib);
hl = basePack->idroot->get(plib,0);
omFreeBinAddr(plib);
if((hl==NULL) ||(IDTYP(hl)!=PACKAGE_CMD))
{
return FALSE;
}
if ((IDPACKAGE(hl)->language!=LANG_C)&&(IDPACKAGE(hl)->libname!=NULL))
return (strcmp(lib,IDPACKAGE(hl)->libname)==0);
return FALSE;
}

## iiHighCorner()

poly iiHighCorner | ( | ideal | i,
|  | int | ak )

the largest monomial in R/I

Definition at line 1606 of file ipshell.cc.

{
int i;
if(!idIsZeroDim(I)) return NULL; // not zero-dim.
poly po=NULL;
if (rHasLocalOrMixedOrdering(currRing))
{
scComputeHC(I,currRing->qideal,ak,po);
if (po!=NULL)
{
pGetCoeff(po)=nInit(1);
for (i=rVar(currRing); i>0; i--)
{
int e;
if ((e=pGetExp(po, i)) > 0) pSetExp(po,i,e-1);
}
pSetComp(po,ak);
pSetm(po);
}
}
else
po=pOne();
return po;
}
scComputeHC
void scComputeHC(ideal S, ideal Q, int ak, poly &hEdge)
Definition hdegree.cc:1074
idIsZeroDim
static BOOLEAN idIsZeroDim(ideal i)
Definition ideals.h:180
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
nInit
#define nInit(i)
Definition numbers.h:24
pSetm
#define pSetm(p)
Definition polys.h:272
pSetComp
#define pSetComp(p, v)
Definition polys.h:39
pGetExp
#define pGetExp(p, i)
Exponent.
Definition polys.h:42
pSetExp
#define pSetExp(p, i, v)
Definition polys.h:43
pOne
#define pOne()
Definition polys.h:316
rHasLocalOrMixedOrdering
static BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition ring.h:769
rVar
static short rVar(const ring r)
define rVar(r) (r->N)
Definition ring.h:598

## iiInternalExport()

BOOLEAN iiInternalExport | ( | leftv | v,
|  | int | toLev,
|  | package | pack )

Definition at line 1464 of file ipshell.cc.

{
idhdl h=(idhdl)v->data;
if(h==NULL)
{
Warn("'%s': no such identifier\n", v->name);
return FALSE;
}
package frompack=v->req_packhdl;
if (frompack==NULL) frompack=currPack;
if ((RingDependend(IDTYP(h)))
|| ((IDTYP(h)==LIST_CMD)
&& (lRingDependend(IDLIST(h)))
)
)
{
//Print("// ==> Ringdependent set nesting to 0\n");
return (iiInternalExport(v, toLev));
}
else
{
IDLEV(h)=toLev;
v->req_packhdl=rootpack;
if (h==frompack->idroot)
{
frompack->idroot=h->next;
}
else
{
idhdl hh=frompack->idroot;
while ((hh!=NULL) && (hh->next!=h))
hh=hh->next;
if ((hh!=NULL) && (hh->next==h))
hh->next=h->next;
else
{
Werror("`%s` not found",v->Name());
return TRUE;
}
}
h->next=rootpack->idroot;
rootpack->idroot=h;
}
return FALSE;
}

## iiLibCmd()

BOOLEAN iiLibCmd | ( | const char * | newlib,
|  | BOOLEAN | autoexport,
|  | BOOLEAN | tellerror,
|  | BOOLEAN | force )

Definition at line 894 of file iplib.cc.

{
if (strcmp(newlib,"Singular")==0) return FALSE;
char libnamebuf[1024];
idhdl pl;
char *plib = iiConvName(newlib);
FILE * fp = feFopen( newlib, "r", libnamebuf, tellerror );
// int lines = 1;
BOOLEAN LoadResult = TRUE;
if (fp==NULL)
{
return TRUE;
}
pl = basePack->idroot->get(plib,0);
if (pl==NULL)
{
pl = enterid( plib,0, PACKAGE_CMD,
&(basePack->idroot), TRUE );
IDPACKAGE(pl)->language = LANG_SINGULAR;
IDPACKAGE(pl)->libname=omStrDup(newlib);
}
else
{
if(IDTYP(pl)!=PACKAGE_CMD)
{
omFreeBinAddr(plib);
WarnS("not of type package.");
fclose(fp);
return TRUE;
}
if (!force)
{
omFreeBinAddr(plib);
return FALSE;
}
}
LoadResult = iiLoadLIB(fp, libnamebuf, newlib, pl, autoexport, tellerror);
if(!LoadResult) IDPACKAGE(pl)->loaded = TRUE;
omFree((ADDRESS)plib);
return LoadResult;
}
fp
CanonicalForm fp
Definition cfModGcd.cc:4110
feFopen
FILE * feFopen(const char *path, const char *mode, char *where, short useWerror, short path_only)
Definition feFopen.cc:47
iiLoadLIB
BOOLEAN iiLoadLIB(FILE *fp, const char *libnamebuf, const char *newlib, idhdl pl, BOOLEAN autoexport, BOOLEAN tellerror)
Definition iplib.cc:983
libnamebuf
VAR char libnamebuf[1024]
Definition libparse.cc:1098

## iiLoadLIB()

BOOLEAN iiLoadLIB | ( | FILE * | fp,
|  | const char * | libnamebuf,
|  | const char * | newlib,
|  | idhdl | pl,
|  | BOOLEAN | autoexport,
|  | BOOLEAN | tellerror )

Definition at line 983 of file iplib.cc.

{
EXTERN_VAR FILE *yylpin;
libstackv ls_start = library_stack;
lib_style_types lib_style;
yylpin = fp;
#if YYLPDEBUG > 1
print_init();
#endif
EXTERN_VAR int lpverbose;
if (BVERBOSE(V_DEBUG_LIB)) lpverbose=1;
else lpverbose=0;
// yylplex sets also text_buffer
if (text_buffer!=NULL) *text_buffer='\0';
yylplex(newlib, libnamebuf, &lib_style, pl, autoexport);
if(yylp_errno)
{
Werror("Library %s: ERROR occurred: in line %d, %d.", newlib, yylplineno,
current_pos(0));
if(yylp_errno==YYLP_BAD_CHAR)
{
Werror(yylp_errlist[yylp_errno], *text_buffer, yylplineno);
omFree((ADDRESS)text_buffer);
text_buffer=NULL;
}
else
Werror(yylp_errlist[yylp_errno], yylplineno);
WerrorS("Cannot load library,... aborting.");
reinit_yylp();
fclose( yylpin );
iiCleanProcs(IDROOT);
return TRUE;
}
if (BVERBOSE(V_LOAD_LIB))
Print( "// ** loaded %s %s\n", libnamebuf, text_buffer);
if( (lib_style == OLD_LIBSTYLE) && (BVERBOSE(V_LOAD_LIB)))
{
Warn( "library %s has old format. This format is still accepted,", newlib);
WarnS( "but for functionality you may wish to change to the new");
WarnS( "format. Please refer to the manual for further information.");
}
reinit_yylp();
fclose( yylpin );
fp = NULL;
iiRunInit(IDPACKAGE(pl));
{
libstackv ls;
for(ls = library_stack; (ls != NULL) && (ls != ls_start); )
{
if(ls->to_be_done)
{
ls->to_be_done=FALSE;
iiLibCmd(ls->get(),autoexport,tellerror,FALSE);
ls = ls->pop(newlib);
}
}
#if 0
PrintS("--------------------\n");
for(ls = library_stack; ls != NULL; ls = ls->next)
{
Print("%s: LIB-stack:(%d), %s %s\n", newlib, ls->cnt, ls->get(),
ls->to_be_done ? "not loaded" : "loaded");
}
PrintS("--------------------\n");
#endif
}
if(fp != NULL) fclose(fp);
return FALSE;
}
libstack::get
char * get()
Definition subexpr.h:170
libstack::next
libstackv next
Definition subexpr.h:164
libstack::pop
libstackv pop(const char *p)
Definition iplib.cc:1531
libstack::cnt
int cnt
Definition subexpr.h:167
libstack::to_be_done
BOOLEAN to_be_done
Definition subexpr.h:166
EXTERN_VAR
#define EXTERN_VAR
Definition globaldefs.h:6
current_pos
int current_pos(int i=0)
Definition libparse.cc:3346
print_init
void print_init()
Definition libparse.cc:3482
iiCleanProcs
static void iiCleanProcs(idhdl &root)
Definition iplib.cc:938
library_stack
VAR libstackv library_stack
Definition iplib.cc:68
yylp_errlist
const char * yylp_errlist[]
Definition libparse.cc:1114
yylplineno
EXTERN_VAR int yylplineno
Definition iplib.cc:65
iiRunInit
static void iiRunInit(package p)
Definition iplib.cc:967
yylp_errno
EXTERN_VAR int yylp_errno
Definition iplib.cc:64
reinit_yylp
void reinit_yylp()
Definition libparse.cc:3376
text_buffer
VAR char * text_buffer
Definition libparse.cc:1099
lpverbose
VAR int lpverbose
Definition libparse.cc:1106
lib_style_types
lib_style_types
Definition libparse.h:9
OLD_LIBSTYLE
@ OLD_LIBSTYLE
Definition libparse.h:9
YYLP_BAD_CHAR
#define YYLP_BAD_CHAR
Definition libparse.h:93
yylplex
int yylplex(const char *libname, const char *libfile, lib_style_types *lib_style, idhdl pl, BOOLEAN autoexport=FALSE, lp_modes=LOAD_LIB)
V_DEBUG_LIB
#define V_DEBUG_LIB
Definition options.h:48
V_LOAD_LIB
#define V_LOAD_LIB
Definition options.h:47
libstackv
libstack * libstackv
Definition subexpr.h:159

## iiLocateLib()

BOOLEAN iiLocateLib | ( | const char * | lib,
|  | char * | where )

Definition at line 880 of file iplib.cc.

{
char *plib = iiConvName(lib);
idhdl pl = basePack->idroot->get(plib,0);
if( (pl!=NULL) && (IDTYP(pl)==PACKAGE_CMD) &&
(IDPACKAGE(pl)->language == LANG_SINGULAR))
{
strncpy(where,IDPACKAGE(pl)->libname,127);
return TRUE;
}
else
return FALSE;;
}

## iiMake_proc()

BOOLEAN iiMake_proc | ( | idhdl | pn,
|  | package | pack,
|  | leftv | sl )

Definition at line 513 of file iplib.cc.

{
int err;
procinfov pi = IDPROC(pn);
if(pi->is_static && myynest==0)
{
Werror("'%s::%s()' is a local procedure and cannot be accessed by an user.",
pi->libname, pi->procname);
return TRUE;
}
iiCheckNest();
iiLocalRing[myynest]=currRing;
//Print("currRing(%d):%s(%x) in %s\n",myynest,IDID(currRingHdl),currRing,IDID(pn));
iiRETURNEXPR.Init();
procstack->push(pi->procname);
if ((traceit&TRACE_SHOW_PROC)
|| (pi->trace_flag&TRACE_SHOW_PROC))
{
if (traceit&TRACE_SHOW_LINENO) PrintLn();
Print("entering%-*.*s %s (level %d)\n",myynest*2,myynest*2," ",IDID(pn),myynest);
}
#ifdef RDEBUG
if (traceit&TRACE_SHOW_RINGS) iiShowLevRings();
#endif
switch (pi->language)
{
default:
case LANG_NONE:
WerrorS("undefined proc");
err=TRUE;
break;
case LANG_SINGULAR:
if ((pi->pack!=NULL)&&(currPack!=pi->pack))
{
currPack=pi->pack;
iiCheckPack(currPack);
currPackHdl=packFindHdl(currPack);
//Print("set pack=%s\n",IDID(currPackHdl));
}
else if ((pack!=NULL)&&(currPack!=pack))
{
currPack=pack;
iiCheckPack(currPack);
currPackHdl=packFindHdl(currPack);
//Print("set pack=%s\n",IDID(currPackHdl));
}
err=iiPStart(pn,args);
break;
case LANG_C:
leftv res = (leftv)omAlloc0Bin(sleftv_bin);
err = (pi->data.o.function)(res, args);
memcpy(&iiRETURNEXPR,res,sizeof(iiRETURNEXPR));
omFreeBin((ADDRESS)res, sleftv_bin);
break;
}
if ((traceit&TRACE_SHOW_PROC)
|| (pi->trace_flag&TRACE_SHOW_PROC))
{
if (traceit&TRACE_SHOW_LINENO) PrintLn();
Print("leaving %-*.*s %s (level %d)\n",myynest*2,myynest*2," ",IDID(pn),myynest);
}
//const char *n="NULL";
//if (currRingHdl!=NULL) n=IDID(currRingHdl);
//Print("currRing(%d):%s(%x) after %s\n",myynest,n,currRing,IDID(pn));
#ifdef RDEBUG
if (traceit&TRACE_SHOW_RINGS) iiShowLevRings();
#endif
if (err)
{
iiRETURNEXPR.CleanUp();
//iiRETURNEXPR.Init(); //done by CleanUp
}
if (iiCurrArgs!=NULL)
{
if (!err) Warn("too many arguments for %s",IDID(pn));
iiCurrArgs->CleanUp();
omFreeBin((ADDRESS)iiCurrArgs, sleftv_bin);
iiCurrArgs=NULL;
}
procstack->pop();
if (err)
return TRUE;
return FALSE;
}
iiShowLevRings
static void iiShowLevRings()
Definition iplib.cc:487
iiPStart
BOOLEAN iiPStart(idhdl pn, leftv v)
Definition iplib.cc:379
TRACE_SHOW_RINGS
#define TRACE_SHOW_RINGS
Definition reporter.h:36

## iiMakeResolv()

void iiMakeResolv | ( | resolvente | r,
|  | int | length,
|  | int | rlen,
|  | char * | name,
|  | int | typ0,
|  | intvec ** | weights = NULL )

Definition at line 854 of file ipshell.cc.

{
lists L=liMakeResolv(r,length,rlen,typ0,weights);
int i=0;
idhdl h;
size_t len=strlen(name)+5;
char * s=(char *)omAlloc(len);
while (i<=L->nr)
{
snprintf(s,len,"%s(%d)",name,i+1);
if (i==0)
h=enterid(s,myynest,typ0,&(currRing->idroot), FALSE);
else
h=enterid(s,myynest,MODUL_CMD,&(currRing->idroot), FALSE);
if (h!=NULL)
{
h->data.uideal=(ideal)L->m[i].data;
h->attribute=L->m[i].attribute;
if (BVERBOSE(V_DEF_RES))
Print("//defining: %s as %d-th syzygy module\n",s,i+1);
}
else
{
idDelete((ideal *)&(L->m[i].data));
Warn("cannot define %s",s);
}
//L->m[i].data=NULL;
//L->m[i].rtyp=0;
//L->m[i].attribute=NULL;
i++;
}
omFreeSize((ADDRESS)L->m,(L->nr+1)*sizeof(sleftv));
omFreeBin((ADDRESS)L, slists_bin);
omFreeSize((ADDRESS)s,strlen(name)+5);
}
sleftv::attribute
attr attribute
Definition subexpr.h:89
slists::m
sleftv * m
Definition lists.h:46
slists::nr
int nr
Definition lists.h:44
length
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257
slists_bin
VAR omBin slists_bin
Definition lists.cc:23
liMakeResolv
lists liMakeResolv(resolvente r, int length, int reallen, int typ0, intvec **weights, int add_row_shift)
Definition lists.cc:239
omFreeSize
#define omFreeSize(addr, size)
Definition omAllocDecl.h:260
V_DEF_RES
#define V_DEF_RES
Definition options.h:50

## iiMap()

leftv iiMap | ( | map | theMap,
|  | const char * | what )

Definition at line 618 of file ipshell.cc.

{
idhdl w,r;
leftv v;
int i;
nMapFunc nMap;
r=IDROOT->get(theMap->preimage,myynest);
if ((currPack!=basePack)
&&((r==NULL) || ((r->typ != RING_CMD) )))
r=basePack->idroot->get(theMap->preimage,myynest);
if ((r==NULL) && (currRingHdl!=NULL)
&& (strcmp(theMap->preimage,IDID(currRingHdl))==0))
{
r=currRingHdl;
}
if ((r!=NULL) && (r->typ == RING_CMD))
{
ring src_ring=IDRING(r);
if ((nMap=n_SetMap(src_ring->cf, currRing->cf))==NULL)
{
Werror("can not map from ground field of %s to current ground field",
theMap->preimage);
return NULL;
}
if (IDELEMS(theMap)<src_ring->N)
{
theMap->m=(polyset)omReallocSize((ADDRESS)theMap->m,
IDELEMS(theMap)*sizeof(poly),
(src_ring->N)*sizeof(poly));
#ifdef HAVE_SHIFTBBA
if (rIsLPRing(src_ring))
{
// src_ring [x,y,z,...]
// curr_ring [a,b,c,...]
//
// map=[a,b,c,d] -> [a,b,c,...]
// map=[a,b] -> [a,b,0,...]
short src_lV = src_ring->isLPring;
short src_ncGenCount = src_ring->LPncGenCount;
short src_nVars = src_lV - src_ncGenCount;
int src_nblocks = src_ring->N / src_lV;
short dest_nVars = currRing->isLPring - currRing->LPncGenCount;
short dest_ncGenCount = currRing->LPncGenCount;
// add missing NULL generators
for(i=IDELEMS(theMap); i < src_lV - src_ncGenCount; i++)
{
theMap->m[i]=NULL;
}
// remove superfluous generators
for(i = src_nVars; i < IDELEMS(theMap); i++)
{
if (theMap->m[i] != NULL)
{
p_Delete(&(theMap->m[i]), currRing);
theMap->m[i] = NULL;
}
}
// add ncgen mappings
for(i = src_nVars; i < src_lV; i++)
{
short ncGenIndex = i - src_nVars;
if (ncGenIndex < dest_ncGenCount)
{
poly p = p_One(currRing);
p_SetExp(p, dest_nVars + ncGenIndex + 1, 1, currRing);
p_Setm(p, currRing);
theMap->m[i] = p;
}
else
{
theMap->m[i] = NULL;
}
}
// copy the first block to all other blocks
for(i = 1; i < src_nblocks; i++)
{
for(int j = 0; j < src_lV; j++)
{
theMap->m[(i * src_lV) + j] = p_Copy(theMap->m[j], currRing);
}
}
}
else
{
#endif
for(i=IDELEMS(theMap);i<src_ring->N;i++)
theMap->m[i]=NULL;
#ifdef HAVE_SHIFTBBA
}
#endif
IDELEMS(theMap)=src_ring->N;
}
if (what==NULL)
{
WerrorS("argument of a map must have a name");
}
else if ((w=src_ring->idroot->get(what,myynest))!=NULL)
{
char *save_r=NULL;
v=(leftv)omAlloc0Bin(sleftv_bin);
sleftv tmpW;
tmpW.Init();
tmpW.rtyp=IDTYP(w);
if (tmpW.rtyp==MAP_CMD)
{
tmpW.rtyp=IDEAL_CMD;
save_r=IDMAP(w)->preimage;
IDMAP(w)->preimage=0;
}
tmpW.data=IDDATA(w);
// check overflow
BOOLEAN overflow=FALSE;
if ((tmpW.rtyp==IDEAL_CMD)
|| (tmpW.rtyp==MODUL_CMD)
|| (tmpW.rtyp==SMATRIX_CMD)
|| (tmpW.rtyp==MAP_CMD))
{
ideal id=(ideal)tmpW.data;
long *degs=NULL;
if (IDELEMS(id)>0) degs=(long*)omAlloc(IDELEMS(id)*sizeof(long));
for(int i=IDELEMS(id)-1;i>=0;i--)
{
poly p=id->m[i];
if (p!=NULL) degs[i]=p_Totaldegree(p,src_ring);
else degs[i]=0;
}
for(int j=IDELEMS(theMap)-1;j>=0 && !overflow;j--)
{
if (theMap->m[j]!=NULL)
{
long deg_monexp=pTotaldegree(theMap->m[j]);
for(int i=IDELEMS(id)-1;i>=0;i--)
{
poly p=id->m[i];
if ((p!=NULL) && (degs[i]!=0) &&
((unsigned long)deg_monexp > (currRing->bitmask / ((unsigned long)degs[i])/2)))
{
overflow=TRUE;
break;
}
}
}
}
if (degs!=NULL) omFreeSize(degs,IDELEMS(id)*sizeof(long));
}
else if ((tmpW.rtyp==POLY_CMD)
|| (tmpW.rtyp==VECTOR_CMD))
{
for(int j=IDELEMS(theMap)-1;j>=0 && !overflow;j--)
{
if (theMap->m[j]!=NULL)
{
long deg_monexp=pTotaldegree(theMap->m[j]);
poly p=(poly)tmpW.data;
long deg=0;
if ((p!=NULL) && ((deg=p_Totaldegree(p,src_ring))!=0) &&
((unsigned long)deg_monexp > (currRing->bitmask / ((unsigned long)deg)/2)))
{
overflow=TRUE;
break;
}
}
}
}
if (overflow)
#ifdef HAVE_SHIFTBBA
// in Letterplace rings the exponent is always 0 or 1! ignore this warning.
if (!rIsLPRing(currRing))
{
#endif
Warn("possible OVERFLOW in map, max exponent is %ld",currRing->bitmask/2);
#ifdef HAVE_SHIFTBBA
}
#endif
#if 0
if (((tmpW.rtyp==IDEAL_CMD)||(tmpW.rtyp==MODUL_CMD)) && idIs0(IDIDEAL(w)))
{
v->rtyp=tmpW.rtyp;
v->data=idInit(IDELEMS(IDIDEAL(w)),IDIDEAL(w)->rank);
}
else
#endif
{
if ((tmpW.rtyp==IDEAL_CMD)
||(tmpW.rtyp==MODUL_CMD)
||(tmpW.rtyp==MATRIX_CMD)
||(tmpW.rtyp==SMATRIX_CMD)
||(tmpW.rtyp==MAP_CMD))
{
v->rtyp=tmpW.rtyp;
char *tmp = theMap->preimage;
theMap->preimage=(char*)1L;
// map gets 1 as its rank (as an ideal)
v->data=maMapIdeal(IDIDEAL(w), src_ring, (ideal)theMap, currRing,nMap);
theMap->preimage=tmp; // map gets its preimage back
}
if (v->data==NULL) /*i.e. not IDEAL/MODUL/SMATRIX/MATRIX/MAP */
{
if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,src_ring,NULL,NULL,0,nMap))
{
Werror("cannot map %s(%d)",Tok2Cmdname(w->typ),w->typ);
omFreeBin((ADDRESS)v, sleftv_bin);
if (save_r!=NULL) IDMAP(w)->preimage=save_r;
return NULL;
}
}
}
if (save_r!=NULL)
{
IDMAP(w)->preimage=save_r;
IDMAP((idhdl)v)->preimage=omStrDup(save_r);
v->rtyp=MAP_CMD;
}
return v;
}
else
{
Werror("%s undefined in %s",what,theMap->preimage);
}
}
else
{
Werror("cannot find preimage %s",theMap->preimage);
}
return NULL;
}
idrec::typ
int typ
Definition idrec.h:43
n_SetMap
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition coeffs.h:703
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
w
const CanonicalForm & w
Definition facAbsFact.cc:51
maMapIdeal
ideal maMapIdeal(const ideal map_id, const ring preimage_r, const ideal image_id, const ring image_r, const nMapFunc nMap)
polynomial map for ideals/module/matrix map_id: the ideal to map map_r: the base ring for map_id imag...
Definition gen_maps.cc:88
SMATRIX_CMD
@ SMATRIX_CMD
Definition grammar.cc:292
idIs0
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
Definition simpleideals.cc:960
maApplyFetch
BOOLEAN maApplyFetch(int what, map theMap, leftv res, leftv w, ring preimage_r, int *perm, int *par_perm, int P, nMapFunc nMap)
Definition maps_ip.cc:45
omReallocSize
#define omReallocSize(addr, o_size, size)
Definition omAllocDecl.h:220
p_One
poly p_One(const ring r)
Definition p_polys.cc:1314
p_SetExp
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition p_polys.h:490
p_Setm
static void p_Setm(poly p, const ring r)
Definition p_polys.h:235
p_Delete
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:848
p_Totaldegree
static long p_Totaldegree(poly p, const ring r)
Definition p_polys.h:1528
pTotaldegree
static long pTotaldegree(poly p)
Definition polys.h:283
polyset
poly * polyset
Definition polys.h:260
rIsLPRing
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:417
IDELEMS
#define IDELEMS(i)
Definition simpleideals.h:23

## iiOpsTwoChar()

int iiOpsTwoChar | ( | const char * | s | ) |

Definition at line 122 of file ipshell.cc.

{
/* not handling: &&, ||, ** */
if (s[1]=='\0') return s[0];
else if (s[2]!='\0') return 0;
switch(s[0])
{
case '.': if (s[1]=='.') return DOTDOT;
else return 0;
case ':': if (s[1]==':') return COLONCOLON;
else return 0;
case '-': if (s[1]=='-') return MINUSMINUS;
else return 0;
case '+': if (s[1]=='+') return PLUSPLUS;
else return 0;
case '=': if (s[1]=='=') return EQUAL_EQUAL;
else return 0;
case '<': if (s[1]=='=') return LE;
else if (s[1]=='>') return NOTEQUAL;
else return 0;
case '>': if (s[1]=='=') return GE;
else return 0;
case '!': if (s[1]=='=') return NOTEQUAL;
else return 0;
}
return 0;
}
PLUSPLUS
@ PLUSPLUS
Definition grammar.cc:274
MINUSMINUS
@ MINUSMINUS
Definition grammar.cc:271
GE
@ GE
Definition grammar.cc:269
EQUAL_EQUAL
@ EQUAL_EQUAL
Definition grammar.cc:268
LE
@ LE
Definition grammar.cc:270
NOTEQUAL
@ NOTEQUAL
Definition grammar.cc:273
DOTDOT
@ DOTDOT
Definition grammar.cc:267
COLONCOLON
@ COLONCOLON
Definition grammar.cc:275

## iiParameter()

BOOLEAN iiParameter | ( | leftv | p | ) |

Definition at line 1384 of file ipshell.cc.

{
if (iiCurrArgs==NULL)
{
if (strcmp(p->name,"#")==0)
return iiDefaultParameter(p);
Werror("not enough arguments for proc %s",VoiceName());
p->CleanUp();
return TRUE;
}
leftv h=iiCurrArgs;
leftv rest=h->next; /*iiCurrArgs is not NULL here*/
if (strcmp(p->name,"#")==0)
{
rest=NULL;
}
else
{
h->next=NULL;
}
BOOLEAN res=iiAssign(p,h);
iiCurrArgs=rest; // may be NULL
h->CleanUp();
omFreeBin((ADDRESS)h, sleftv_bin);
return res;
}
iiDefaultParameter
BOOLEAN iiDefaultParameter(leftv p)
Definition ipshell.cc:1268

## iiProcArgs()

char * iiProcArgs | ( | char * | e,
|  | BOOLEAN | withParenth )

Definition at line 114 of file iplib.cc.

{
while ((*e==' ') || (*e=='\t') || (*e=='(')) e++;
if (*e<' ')
{
if (withParenth)
{
// no argument list, allow list #
return omStrDup("parameter list #;");
}
else
{
// empty list
return omStrDup("");
}
}
BOOLEAN in_args;
BOOLEAN args_found;
char *s;
char *argstr=(char *)omAlloc(127); // see ../omalloc/omTables.inc
int argstrlen=127;
*argstr='\0';
int par=0;
do
{
args_found=FALSE;
s=e; // set s to the starting point of the arg
// and search for the end
// skip leading spaces:
loop
{
if ((*s==' ')||(*s=='\t'))
s++;
else if ((*s=='\n')&&(*(s+1)==' '))
s+=2;
else // start of new arg or \0 or )
break;
}
e=s;
while ((*e!=',')
&&((par!=0) || (*e!=')'))
&&(*e!='\0'))
{
if (*e=='(') par++;
else if (*e==')') par--;
args_found=args_found || (*e>' ');
e++;
}
in_args=(*e==',');
if (args_found)
{
*e='\0';
// check for space:
if ((int)strlen(argstr)+12 /* parameter + ;*/ +(int)strlen(s)>= argstrlen)
{
argstrlen*=2;
char *a=(char *)omAlloc( argstrlen);
strcpy(a,argstr);
omFree((ADDRESS)argstr);
argstr=a;
}
// copy the result to argstr
if(strncmp(s,"alias ",6)!=0)
{
strcat(argstr,"parameter ");
}
strcat(argstr,s);
strcat(argstr,"; ");
e++; // e was pointing to ','
}
} while (in_args);
return argstr;
}

## iiProcName()

char * iiProcName | ( | char * | buf,
|  | char & | ct,
|  | char *& | e )

Definition at line 100 of file iplib.cc.

{
char *s=buf+5;
while (*s==' ') s++;
e=s+1;
while ((*e>' ') && (*e!='(')) e++;
ct=*e;
*e='\0';
return s;
}
buf
int status int void * buf
Definition si_signals.h:69

## iiPStart()

BOOLEAN iiPStart | ( | idhdl | pn,
|  | leftv | sl )

Definition at line 379 of file iplib.cc.

{
procinfov pi=NULL;
int old_echo=si_echo;
BOOLEAN err=FALSE;
char save_flags=0;
/* init febase ======================================== */
/* we do not enter this case if filename != NULL !! */
if (pn!=NULL)
{
pi = IDPROC(pn);
if(pi!=NULL)
{
save_flags=pi->trace_flag;
if( pi->data.s.body==NULL )
{
iiGetLibProcBuffer(pi);
if (pi->data.s.body==NULL) return TRUE;
}
// omUpdateInfo();
// int m=om_Info.UsedBytes;
// Print("proc %s, mem=%d\n",IDID(pn),m);
}
}
else return TRUE;
/* generate argument list ======================================*/
//iiCurrArgs should be NULL here, as the assignment for the parameters
// of the prevouis call are already done befor calling another routine
if (v!=NULL)
{
iiCurrArgs=(leftv)omAllocBin(sleftv_bin);
memcpy(iiCurrArgs,v,sizeof(sleftv)); // keeps track of v->next etc.
v->Init();
}
else
{
if (iiCurrArgs!=NULL) omFreeBin(iiCurrArgs,sleftv_bin);
iiCurrArgs=NULL;
}
/* start interpreter ======================================*/
myynest++;
if (myynest > SI_MAX_NEST)
{
WerrorS("nesting too deep");
err=TRUE;
}
else
{
iiCurrProc=pn;
err=iiAllStart(pi,pi->data.s.body,BT_proc,pi->data.s.body_lineno-(v!=NULL));
iiCurrProc=NULL;
if (iiLocalRing[myynest-1] != currRing)
{
if (iiRETURNEXPR.RingDependend())
{
//idhdl hn;
const char *n;
const char *o;
idhdl nh=NULL, oh=NULL;
if (iiLocalRing[myynest-1]!=NULL)
oh=rFindHdl(iiLocalRing[myynest-1],NULL);
if (oh!=NULL) o=oh->id;
else o="none";
if (currRing!=NULL)
nh=rFindHdl(currRing,NULL);
if (nh!=NULL) n=nh->id;
else n="none";
Werror("ring change during procedure call %s: %s -> %s (level %d)",pi->procname,o,n,myynest);
iiRETURNEXPR.CleanUp();
err=TRUE;
}
currRing=iiLocalRing[myynest-1];
}
if ((currRing==NULL)
&& (currRingHdl!=NULL))
currRing=IDRING(currRingHdl);
else
if ((currRing!=NULL) &&
((currRingHdl==NULL)||(IDRING(currRingHdl)!=currRing)
||(IDLEV(currRingHdl)>=myynest-1)))
{
rSetHdl(rFindHdl(currRing,NULL));
iiLocalRing[myynest-1]=NULL;
}
//Print("kill locals for %s (level %d)\n",IDID(pn),myynest);
killlocals(myynest);
#ifndef SING_NDEBUG
checkall();
#endif
//Print("end kill locals for %s (%d)\n",IDID(pn),myynest);
}
myynest--;
si_echo=old_echo;
if (pi!=NULL)
pi->trace_flag=save_flags;
// omUpdateInfo();
// int m=om_Info.UsedBytes;
// Print("exit %s, mem=%d\n",IDID(pn),m);
return err;
}
idrec::id
const char * id
Definition idrec.h:39
SI_MAX_NEST
#define SI_MAX_NEST
Definition iplib.cc:27

## iiRegularity()

int iiRegularity | ( | lists | L | ) |

Definition at line 1045 of file ipshell.cc.

{
int len,reg,typ0;
resolvente r=liFindRes(L,&len,&typ0);
if (r==NULL)
return -2;
intvec *weights=NULL;
int add_row_shift=0;
intvec *ww=(intvec *)atGet(&(L->m[0]),"isHomog",INTVEC_CMD);
if (ww!=NULL)
{
weights=ivCopy(ww);
add_row_shift = ww->min_in();
(*weights) -= add_row_shift;
}
//Print("attr:%x\n",weights);
intvec *dummy=syBetti(r,len,&reg,weights);
if (weights!=NULL) delete weights;
delete dummy;
omFreeSize((ADDRESS)r,len*sizeof(ideal));
return reg+1+add_row_shift;
}
atGet
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition attrib.cc:132
intvec::min_in
int min_in()
Definition intvec.h:122
resolvente
ideal * resolvente
Definition ideals.h:18
ivCopy
intvec * ivCopy(const intvec *o)
Definition intvec.h:146
liFindRes
resolvente liFindRes(lists L, int *len, int *typ0, intvec ***weights)
Definition lists.cc:344
syBetti
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
Definition syz.cc:787

## iiSetReturn()

void iiSetReturn | ( | const leftv | h | ) |

Definition at line 6634 of file ipshell.cc.

{
if ((source->next==NULL)&&(source->e==NULL))
{
if ((source->rtyp!=IDHDL)&&(source->rtyp!=ALIAS_CMD))
{
memcpy(&iiRETURNEXPR,source,sizeof(sleftv));
source->Init();
return;
}
if (source->rtyp==IDHDL)
{
if ((IDLEV((idhdl)source->data)==myynest)
&&(IDTYP((idhdl)source->data)!=RING_CMD))
{
iiRETURNEXPR.Init();
iiRETURNEXPR.rtyp=IDTYP((idhdl)source->data);
iiRETURNEXPR.data=IDDATA((idhdl)source->data);
iiRETURNEXPR.flag=IDFLAG((idhdl)source->data);
iiRETURNEXPR.attribute=IDATTR((idhdl)source->data);
IDATTR((idhdl)source->data)=NULL;
IDDATA((idhdl)source->data)=NULL;
source->name=NULL;
source->attribute=NULL;
return;
}
}
}
iiRETURNEXPR.Copy(source);
}

## iiTestAssume()

BOOLEAN iiTestAssume | ( | leftv | a,
|  | leftv | b )

Definition at line 6453 of file ipshell.cc.

{
// assume a: level
if ((a->Typ()==INT_CMD)&&((long)a->Data()>=0))
{
if ((TEST_V_ALLWARN) && (myynest==0)) WarnS("ASSUME at top level is of no use: see documentation");
char assume_yylinebuf[80];
strncpy(assume_yylinebuf,my_yylinebuf,79);
int lev=(long)a->Data();
int startlev=0;
idhdl h=ggetid("assumeLevel");
if ((h!=NULL)&&(IDTYP(h)==INT_CMD)) startlev=(long)IDINT(h);
if(lev <=startlev)
{
BOOLEAN bo=b->Eval();
if (bo) { WerrorS("syntax error in ASSUME");return TRUE;}
if (b->Typ()!=INT_CMD) { WerrorS("ASUMME(<level>,<int expr>)");return TRUE; }
if (b->Data()==NULL) { Werror("ASSUME failed:%s",assume_yylinebuf);return TRUE;}
}
}
b->CleanUp();
a->CleanUp();
return FALSE;
}
sleftv::Data
void * Data()
Definition subexpr.cc:1192
IDINT
#define IDINT(a)
Definition ipid.h:125

## iiTokType()

int iiTokType | ( | int | op | ) |

Definition at line 230 of file iparith.cc.

{
for (unsigned i=0;i<sArithBase.nCmdUsed;i++)
{
if (sArithBase.sCmds[i].tokval==op)
return sArithBase.sCmds[i].toktype;
}
return 0;
}
sArithBase
STATIC_VAR SArithBase sArithBase
Base entry for arithmetic.
Definition iparith.cc:198

## iiTryLoadLib()

BOOLEAN iiTryLoadLib | ( | leftv | v,
|  | const char * | id )

Definition at line 832 of file iplib.cc.

{
BOOLEAN LoadResult = TRUE;
char libnamebuf[1024];
size_t len=strlen(id)+5;
char *libname = (char *)omAlloc(len);
const char *suffix[] = { "", ".lib", ".so", ".sl", NULL };
int i = 0;
// FILE *fp;
// package pack;
// idhdl packhdl;
lib_types LT;
for(i=0; suffix[i] != NULL; i++)
{
snprintf(libname,len, "%s%s", id, suffix[i]);
*libname = mytolower(*libname);
if((LT = type_of_LIB(libname, libnamebuf)) > LT_NOTFOUND)
{
#ifdef HAVE_DYNAMIC_LOADING
char libnamebuf[1024];
#endif
if (LT==LT_SINGULAR)
LoadResult = iiLibCmd(libname, FALSE, FALSE,TRUE);
#ifdef HAVE_DYNAMIC_LOADING
else if ((LT==LT_ELF) || (LT==LT_HPUX))
LoadResult = load_modules(libname,libnamebuf,FALSE);
#endif
else if (LT==LT_BUILTIN)
{
LoadResult=load_builtin(libname,FALSE, iiGetBuiltinModInit(libname));
}
if(!LoadResult )
{
v->name = iiConvName(libname);
break;
}
}
}
omFree(libname);
return LoadResult;
}
load_modules
BOOLEAN load_modules(const char *newlib, char *fullname, BOOLEAN autoexport)
Definition iplib.cc:1294
mytolower
static char mytolower(char c)
Definition iplib.cc:1426
load_builtin
BOOLEAN load_builtin(const char *newlib, BOOLEAN autoexport, SModulFunc_t init)
Definition iplib.cc:1304
iiGetBuiltinModInit
SModulFunc_t iiGetBuiltinModInit(const char *libname)
Definition iplib.cc:816
type_of_LIB
lib_types type_of_LIB(const char *newlib, char *libnamebuf)
Definition mod_lib.cc:27
lib_types
lib_types
Definition mod_raw.h:16
LT_HPUX
@ LT_HPUX
Definition mod_raw.h:16
LT_SINGULAR
@ LT_SINGULAR
Definition mod_raw.h:16
LT_BUILTIN
@ LT_BUILTIN
Definition mod_raw.h:16
LT_ELF
@ LT_ELF
Definition mod_raw.h:16
LT_NOTFOUND
@ LT_NOTFOUND
Definition mod_raw.h:16

## iiTwoOps()

const char * iiTwoOps | ( | int | t | ) |

Definition at line 258 of file gentable.cc.

{
if (t<127)
{
STATIC_VAR char ch[2];
switch (t)
{
case '&':
return "and";
case '|':
return "or";
default:
ch[0]=t;
ch[1]='\0';
return ch;
}
}
switch (t)
{
case COLONCOLON: return "::";
case DOTDOT: return "..";
//case PLUSEQUAL: return "+=";
//case MINUSEQUAL: return "-=";
case MINUSMINUS: return "--";
case PLUSPLUS: return "++";
case EQUAL_EQUAL: return "==";
case LE: return "<=";
case GE: return ">=";
case NOTEQUAL: return "<>";
default: return Tok2Cmdname(t);
}
}
STATIC_VAR
#define STATIC_VAR
Definition globaldefs.h:7

## iiWRITE()

BOOLEAN iiWRITE | ( | leftv | res,
|  | leftv | exprlist )

Definition at line 587 of file ipshell.cc.

{
sleftv vf;
if (iiConvert(v->Typ(),LINK_CMD,iiTestConvert(v->Typ(),LINK_CMD),v,&vf))
{
WerrorS("link expected");
return TRUE;
}
si_link l=(si_link)vf.Data();
if (vf.next == NULL)
{
WerrorS("write: need at least two arguments");
return TRUE;
}
BOOLEAN b;
if (strcmp(l->mode,"string")==0)
b=ssiWrite2(l,res,vf.next);
else
b=slWrite(l,vf.next); /* iiConvert preserves next */
if (b)
{
const char *s;
if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
else s=sNoName_fe;
Werror("cannot write to %s",s);
}
vf.CleanUp();
return b;
}
slWrite
BOOLEAN slWrite(si_link l, leftv v)
Definition silink.cc:307
si_link
ip_link * si_link
Definition silink.h:20
ssiWrite2
BOOLEAN ssiWrite2(si_link l, leftv res, leftv v)
Definition ssiLink.cc:3475

## IsCmd()

int IsCmd | ( | const char * | n,
|  | int & | tok )

Definition at line 9773 of file iparith.cc.

{
int i;
int an=1;
int en=sArithBase.nLastIdentifier;
loop
//for(an=0; an<sArithBase.nCmdUsed; )
{
if(an>=en-1)
{
if (strcmp(n, sArithBase.sCmds[an].name) == 0)
{
i=an;
break;
}
else if ((an!=en) && (strcmp(n, sArithBase.sCmds[en].name) == 0))
{
i=en;
break;
}
else
{
// -- blackbox extensions:
// return 0;
return blackboxIsCmd(n,tok);
}
}
i=(an+en)/2;
if (*n < *(sArithBase.sCmds[i].name))
{
en=i-1;
}
else if (*n > *(sArithBase.sCmds[i].name))
{
an=i+1;
}
else
{
int v=strcmp(n,sArithBase.sCmds[i].name);
if(v<0)
{
en=i-1;
}
else if(v>0)
{
an=i+1;
}
else /*v==0*/
{
break;
}
}
}
lastreserved=sArithBase.sCmds[i].name;
tok=sArithBase.sCmds[i].tokval;
if(sArithBase.sCmds[i].alias==2)
{
Warn("outdated identifier `%s` used - please change your code",
sArithBase.sCmds[i].name);
sArithBase.sCmds[i].alias=1;
}
#if 0
if (currRingHdl==NULL)
{
#ifdef SIQ
if (siq<=0)
{
#endif
if ((tok>=BEGIN_RING) && (tok<=END_RING))
{
WerrorS("no ring active");
return 0;
}
#ifdef SIQ
}
#endif
}
#endif
if (!expected_parms)
{
switch (tok)
{
case IDEAL_CMD:
case INT_CMD:
case INTVEC_CMD:
case MAP_CMD:
case MATRIX_CMD:
case MODUL_CMD:
case POLY_CMD:
case PROC_CMD:
case RING_CMD:
case STRING_CMD:
cmdtok = tok;
break;
}
}
return sArithBase.sCmds[i].toktype;
}
blackboxIsCmd
int blackboxIsCmd(const char *n, int &tok)
used by scanner: returns ROOT_DECL for known types (and the type number in tok)
Definition blackbox.cc:219
END_RING
@ END_RING
Definition grammar.cc:311
BEGIN_RING
@ BEGIN_RING
Definition grammar.cc:283
cmdtok
int cmdtok
Definition grammar.cc:174
expected_parms
BOOLEAN expected_parms
Definition grammar.cc:173
lastreserved
const char * lastreserved
Definition ipshell.cc:83

## jjBETTI()

BOOLEAN jjBETTI | ( | leftv | res,
|  | leftv | v )

Definition at line 975 of file ipshell.cc.

{
sleftv tmp;
tmp.Init();
tmp.rtyp=INT_CMD;
tmp.data=(void *)1;
if ((u->Typ()==IDEAL_CMD)
|| (u->Typ()==MODUL_CMD))
return jjBETTI2_ID(res,u,&tmp);
else
return jjBETTI2(res,u,&tmp);
}
jjBETTI2_ID
BOOLEAN jjBETTI2_ID(leftv res, leftv u, leftv v)
Definition ipshell.cc:988
jjBETTI2
BOOLEAN jjBETTI2(leftv res, leftv u, leftv v)
Definition ipshell.cc:1009

## jjBETTI2()

BOOLEAN jjBETTI2 | ( | leftv | res,
|  | leftv | u,
|  | leftv | v )

Definition at line 1009 of file ipshell.cc.

{
resolvente r;
int len;
int reg,typ0;
lists l=(lists)u->Data();
intvec *weights=NULL;
int add_row_shift=0;
intvec *ww=NULL;
if (l->nr>=0) ww=(intvec *)atGet(&(l->m[0]),"isHomog",INTVEC_CMD);
if (ww!=NULL)
{
weights=ivCopy(ww);
add_row_shift = ww->min_in();
(*weights) -= add_row_shift;
}
//Print("attr:%x\n",weights);
r=liFindRes(l,&len,&typ0);
if (r==NULL) return TRUE;
intvec* res_im=syBetti(r,len,&reg,weights,(int)(long)v->Data());
res->data=(void*)res_im;
omFreeSize((ADDRESS)r,(len)*sizeof(ideal));
//Print("rowShift: %d ",add_row_shift);
for(int i=1;i<=res_im->rows();i++)
{
if (IMATELEM(*res_im,1,i)==0) { add_row_shift--; }
else break;
}
//Print(" %d\n",add_row_shift);
atSet(res,omStrDup("rowShift"),(void*)(long)add_row_shift,INT_CMD);
if (weights!=NULL) delete weights;
return FALSE;
}
atSet
void atSet(idhdl root, char *name, void *data, int typ)
Definition attrib.cc:153
intvec::rows
int rows() const
Definition intvec.h:97
IMATELEM
#define IMATELEM(M, I, J)
Definition intvec.h:86

## jjBETTI2_ID()

BOOLEAN jjBETTI2_ID | ( | leftv | res,
|  | leftv | u,
|  | leftv | v )

Definition at line 988 of file ipshell.cc.

{
lists l=(lists) omAllocBin(slists_bin);
l->Init(1);
l->m[0].rtyp=u->Typ();
l->m[0].data=u->Data();
attr *a=u->Attribute();
if (a!=NULL)
l->m[0].attribute=*a;
sleftv tmp2;
tmp2.Init();
tmp2.rtyp=LIST_CMD;
tmp2.data=(void *)l;
BOOLEAN r=jjBETTI2(res,&tmp2,v);
l->m[0].data=NULL;
l->m[0].attribute=NULL;
l->m[0].rtyp=DEF_CMD;
l->Clean();
return r;
}
attr
sattr * attr
Definition attrib.h:16
sleftv::Attribute
attr * Attribute()
Definition subexpr.cc:1505
tmp2
CFList tmp2
Definition facFqBivar.cc:75

## jjCHARSERIES()

BOOLEAN jjCHARSERIES | ( | leftv | res,
|  | leftv | u )

Definition at line 3349 of file ipshell.cc.

{
res->data=singclap_irrCharSeries((ideal)u->Data(), currRing);
return (res->data==NULL);
}
singclap_irrCharSeries
matrix singclap_irrCharSeries(ideal I, const ring r)
Definition clapsing.cc:1614

## jjIMPORTFROM()

BOOLEAN jjIMPORTFROM | ( | leftv | res,
|  | leftv | u,
|  | leftv | v )

Definition at line 2512 of file ipassign.cc.

{
//Print("importfrom %s::%s ->.\n",v->Name(),u->Name() );
assume(u->Typ()==PACKAGE_CMD);
char *vn=(char *)v->Name();
idhdl h=((package)(u->Data()))->idroot->get(vn /*v->Name()*/, myynest);
if (h!=NULL)
{
//check for existence
if (((package)(u->Data()))==basePack)
{
WarnS("source and destination packages are identical");
return FALSE;
}
idhdl t=basePack->idroot->get(vn /*v->Name()*/, myynest);
if (t!=NULL)
{
if (BVERBOSE(V_REDEFINE)) Warn("redefining %s (%s)",vn,my_yylinebuf);
killhdl(t);
}
sleftv tmp_expr;
if (iiDeclCommand(&tmp_expr,v,myynest,DEF_CMD,&IDROOT)) return TRUE;
sleftv h_expr;
memset(&h_expr,0,sizeof(h_expr));
h_expr.rtyp=IDHDL;
h_expr.data=h;
h_expr.name=vn;
return iiAssign(&tmp_expr,&h_expr);
}
else
{
Werror("`%s` not found in `%s`",v->Name(), u->Name());
return TRUE;
}
return FALSE;
}
killhdl
void killhdl(idhdl h, package proot)
Definition ipid.cc:414
assume
#define assume(x)
Definition mod2.h:389
package
ip_package * package
Definition structs.h:39

## jjLIST_PL()

BOOLEAN jjLIST_PL | ( | leftv | res,
|  | leftv | v )

Definition at line 8250 of file iparith.cc.

{
int sl=0;
if (v!=NULL) sl = v->listLength();
lists L;
if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
{
int add_row_shift = 0;
intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
if (weights!=NULL) add_row_shift=weights->min_in();
L=syConvRes((syStrategy)v->Data(),FALSE,add_row_shift);
}
else
{
L=(lists)omAllocBin(slists_bin);
leftv h=NULL;
int i;
int rt;
L->Init(sl);
for (i=0;i<sl;i++)
{
if (h!=NULL)
{ /* e.g. not in the first step:
* h is the pointer to the old sleftv,
* v is the pointer to the next sleftv
* (in this moment) */
h->next=v;
}
h=v;
v=v->next;
h->next=NULL;
rt=h->Typ();
if (rt==0)
{
L->Clean();
Werror("`%s` is undefined",h->Fullname());
return TRUE;
}
if (rt==RING_CMD)
{
L->m[i].rtyp=rt;
L->m[i].data=rIncRefCnt(((ring)h->Data()));
}
else
L->m[i].Copy(h);
}
}
res->data=(char *)L;
return FALSE;
}
sleftv::Copy
void Copy(leftv e)
Definition subexpr.cc:689
slists::Clean
void Clean(ring r=currRing)
Definition lists.h:26
slists::Init
INLINE_THIS void Init(int l=0)
syConvRes
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
Definition ipshell.cc:3178
rIncRefCnt
static ring rIncRefCnt(ring r)
Definition ring.h:849
syStrategy
ssyStrategy * syStrategy
Definition syz.h:36

## jjLOAD()

BOOLEAN jjLOAD | ( | const char * | s,
|  | BOOLEAN | autoexport = FALSE )

load lib/module given in v

Definition at line 5591 of file iparith.cc.

{
char libnamebuf[1024];
lib_types LT = type_of_LIB(s, libnamebuf);
#ifdef HAVE_DYNAMIC_LOADING
extern BOOLEAN load_modules(const char *newlib, char *fullpath, BOOLEAN autoexport);
#endif /* HAVE_DYNAMIC_LOADING */
switch(LT)
{
default:
case LT_NONE:
Werror("%s: unknown type", s);
break;
case LT_NOTFOUND:
Werror("cannot open %s", s);
break;
case LT_SINGULAR:
{
char *plib = iiConvName(s);
idhdl pl = IDROOT->get_level(plib,0);
if (pl==NULL)
{
pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
IDPACKAGE(pl)->language = LANG_SINGULAR;
IDPACKAGE(pl)->libname=omStrDup(s);
}
else if (IDTYP(pl)!=PACKAGE_CMD)
{
Werror("can not create package `%s`",plib);
omFreeBinAddr(plib);
return TRUE;
}
else /* package */
{
package pa=IDPACKAGE(pl);
if ((pa->language==LANG_C)
|| (pa->language==LANG_MIX))
{
Werror("can not create package `%s` - binaries exists",plib);
omFreeBinAddr(plib);
return TRUE;
}
}
omFreeBinAddr(plib);
package savepack=currPack;
currPack=IDPACKAGE(pl);
IDPACKAGE(pl)->loaded=TRUE;
char libnamebuf[1024];
FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
currPack=savepack;
IDPACKAGE(pl)->loaded=(!bo);
return bo;
}
case LT_BUILTIN:
SModulFunc_t iiGetBuiltinModInit(const char*);
return load_builtin(s,autoexport, iiGetBuiltinModInit(s));
case LT_MACH_O:
case LT_ELF:
case LT_HPUX:
#ifdef HAVE_DYNAMIC_LOADING
return load_modules(s, libnamebuf, autoexport);
#else /* HAVE_DYNAMIC_LOADING */
WerrorS("Dynamic modules are not supported by this version of Singular");
break;
#endif /* HAVE_DYNAMIC_LOADING */
}
return TRUE;
}
pa
static BOOLEAN pa(leftv res, leftv args)
Definition cohomo.cc:3770
load_builtin
BOOLEAN load_builtin(const char *newlib, BOOLEAN autoexport, SModulFunc_t init)
Definition iplib.cc:1304
SModulFunc_t
int(* SModulFunc_t)(SModulFunctions *)
Definition ipid.h:81
LT_MACH_O
@ LT_MACH_O
Definition mod_raw.h:16
LT_NONE
@ LT_NONE
Definition mod_raw.h:16

## jjLOAD_TRY()

BOOLEAN jjLOAD_TRY | ( | const char * | s | ) |

Definition at line 5667 of file iparith.cc.

{
if (!iiGetLibStatus(s))
{
void (*WerrorS_save)(const char *s) = WerrorS_callback;
WerrorS_callback=WerrorS_dummy;
WerrorS_dummy_cnt=0;
BOOLEAN bo=jjLOAD(s,TRUE);
if (TEST_OPT_PROT && (bo || (WerrorS_dummy_cnt>0)))
Print("loading of >%s< failed\n",s);
WerrorS_callback=WerrorS_save;
errorreported=0;
}
return FALSE;
}
WerrorS_callback
VAR void(* WerrorS_callback)(const char *s)
Definition feFopen.cc:21
jjLOAD
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
Definition iparith.cc:5591
WerrorS_dummy_cnt
STATIC_VAR int WerrorS_dummy_cnt
Definition iparith.cc:5662
WerrorS_dummy
static void WerrorS_dummy(const char *)
Definition iparith.cc:5663
iiGetLibStatus
BOOLEAN iiGetLibStatus(const char *lib)
Definition iplib.cc:77
TEST_OPT_PROT
#define TEST_OPT_PROT
Definition options.h:105

## jjMINRES()

BOOLEAN jjMINRES | ( | leftv | res,
|  | leftv | v )

Definition at line 954 of file ipshell.cc.

{
int len=0;
int typ0;
lists L=(lists)v->Data();
intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
int add_row_shift = 0;
if (weights==NULL)
weights=(intvec*)atGet(&(L->m[0]),"isHomog",INTVEC_CMD);
if (weights!=NULL) add_row_shift=weights->min_in();
resolvente rr=liFindRes(L,&len,&typ0);
if (rr==NULL) return TRUE;
resolvente r=iiCopyRes(rr,len);
syMinimizeResolvente(r,len,0);
omFreeSize((ADDRESS)rr,len*sizeof(ideal));
len++;
res->data=(char *)liMakeResolv(r,len,-1,typ0,NULL,add_row_shift);
return FALSE;
}
iiCopyRes
static resolvente iiCopyRes(resolvente r, int l)
Definition ipshell.cc:944
syMinimizeResolvente
void syMinimizeResolvente(resolvente res, int length, int first)
Definition syz.cc:367

## jjRESULTANT()

BOOLEAN jjRESULTANT | ( | leftv | res,
|  | leftv | u,
|  | leftv | v,
|  | leftv | w )

Definition at line 3342 of file ipshell.cc.

{
res->data=singclap_resultant((poly)u->CopyD(),(poly)v->CopyD(),
(poly)w->CopyD(), currRing);
return errorreported;
}
singclap_resultant
poly singclap_resultant(poly f, poly g, poly x, const ring r)
Definition clapsing.cc:357

## jjSetMinpoly()

coeffs jjSetMinpoly | ( | coeffs | cf,
|  | number | a )

Definition at line 176 of file ipassign.cc.

{
if ( !nCoeff_is_transExt(cf) )
{
if(!nCoeff_is_algExt(cf) )
{
WerrorS("cannot set minpoly for these coeffients");
return NULL;
}
}
if (rVar(cf->extRing)!=1)
{
WerrorS("only univariate minpoly allowed");
return NULL;
}
number p = n_Copy(a,cf);
n_Normalize(p, cf);
if (n_IsZero(p, cf))
{
n_Delete(&p, cf);
return cf;
}
AlgExtInfo A;
A.r = rCopy(cf->extRing); // Copy ground field!
// if minpoly was already set:
if( cf->extRing->qideal != NULL ) id_Delete(&(A.r->qideal),A.r);
ideal q = idInit(1,1);
if ((p==NULL) ||(NUM((fraction)p)==NULL))
{
WerrorS("Could not construct the alg. extension: minpoly==0");
// cleanup A: TODO
rDelete( A.r );
return NULL;
}
if (DEN((fraction)(p)) != NULL) // minpoly must be a fraction with poly numerator...!!
{
poly n=DEN((fraction)(p));
if(!p_IsConstant(n,cf->extRing))
{
WarnS("denominator must be constant - ignoring it");
}
p_Delete(&n,cf->extRing);
DEN((fraction)(p))=NULL;
}
q->m[0] = NUM((fraction)p);
A.r->qideal = q;
EXTERN_VAR omBin fractionObjectBin;
NUM((fractionObject *)p) = NULL; // not necessary, but still...
omFreeBin((ADDRESS)p, fractionObjectBin);
coeffs new_cf = nInitChar(n_algExt, &A);
if (new_cf==NULL)
{
WerrorS("Could not construct the alg. extension: illegal minpoly?");
// cleanup A: TODO
rDelete( A.r );
return NULL;
}
return new_cf;
}
AlgExtInfo
struct for passing initialization parameters to naInitChar
Definition algext.h:37
cf
CanonicalForm cf
Definition cfModGcd.cc:4091
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:457
n_algExt
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition coeffs.h:35
nInitChar
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:412
n_IsZero
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition coeffs.h:470
nCoeff_is_algExt
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition coeffs.h:905
n_Normalize
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition coeffs.h:581
nCoeff_is_transExt
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition coeffs.h:913
omBin
omBin_t * omBin
Definition omStructs.h:12
p_IsConstant
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1985
NUM
#define NUM
Definition readcf.cc:180
rDelete
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:454
rCopy
ring rCopy(ring r)
Definition ring.cc:1737
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition simpleideals.cc:123
A
#define A
Definition sirandom.c:24
fractionObjectBin
VAR omBin fractionObjectBin
Definition transext.cc:89

## jjSYSTEM()

BOOLEAN jjSYSTEM | ( | leftv | res,
|  | leftv | v )

Definition at line 227 of file extra.cc.

{
if(args->Typ() == STRING_CMD)
{
const char *sys_cmd=(char *)(args->Data());
leftv h=args->next;
// ONLY documented system calls go here
// Undocumented system calls go down into jjEXTENDED_SYSTEM (#ifdef HAVE_EXTENDED_SYSTEM)
/*==================== nblocks ==================================*/
if (strcmp(sys_cmd, "nblocks") == 0)
{
ring r;
if (h == NULL)
{
if (currRingHdl != NULL)
{
r = IDRING(currRingHdl);
}
else
{
WerrorS("no ring active");
return TRUE;
}
}
else
{
if (h->Typ() != RING_CMD)
{
WerrorS("ring expected");
return TRUE;
}
r = (ring) h->Data();
}
res->rtyp = INT_CMD;
res->data = (void*) (long)(rBlocks(r) - 1);
return FALSE;
}
/*==================== version ==================================*/
if(strcmp(sys_cmd,"version")==0)
{
res->rtyp=INT_CMD;
res->data=(void *)SINGULAR_VERSION;
return FALSE;
}
else
/*==================== alarm ==================================*/
if(strcmp(sys_cmd,"alarm")==0)
{
if ((h!=NULL) &&(h->Typ()==INT_CMD))
{
// standard variant -> SIGALARM (standard: abort)
//alarm((unsigned)h->next->Data());
// process time (user +system): SIGVTALARM
struct itimerval t,o;
memset(&t,0,sizeof(t));
t.it_value.tv_sec =(unsigned)((unsigned long)h->Data());
setitimer(ITIMER_VIRTUAL,&t,&o);
return FALSE;
}
else
WerrorS("int expected");
}
else
/*==================== content ==================================*/
if(strcmp(sys_cmd,"content")==0)
{
if ((h!=NULL) && ((h->Typ()==POLY_CMD)||(h->Typ()==VECTOR_CMD)))
{
int t=h->Typ();
poly p=(poly)h->CopyD();
if (p!=NULL)
{
if (!nCoeff_is_Ring(currRing->cf)) p_Cleardenom(p,currRing);
p_Content(p,currRing);
}
res->data=(void *)p;
res->rtyp=t;
return FALSE;
}
return TRUE;
}
else
/*==================== cpu ==================================*/
if(strcmp(sys_cmd,"cpu")==0)
{
#if 0
long cpu=1;
#ifdef _SC_NPROCESSORS_ONLN
cpu=sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(_SC_NPROCESSORS_CONF)
cpu=sysconf(_SC_NPROCESSORS_CONF);
#endif
res->data=(void *)cpu;
#else
res->data=(void *)feOptValue(FE_OPT_CPUS);
#endif
res->rtyp=INT_CMD;
return FALSE;
}
else
/*==================== executable ==================================*/
if(strcmp(sys_cmd,"executable")==0)
{
if ((h!=NULL) && (h->Typ()==STRING_CMD))
{
char tbuf[MAXPATHLEN];
char *s=omFindExec((char*)h->Data(),tbuf);
if(s==NULL) s=(char*)"";
res->data=(void *)omStrDup(s);
res->rtyp=STRING_CMD;
return FALSE;
}
return TRUE;
}
else
/*==================== flatten =============================*/
if(strcmp(sys_cmd,"flatten")==0)
{
if ((h!=NULL) &&(h->Typ()==SMATRIX_CMD))
{
res->data=(char*)sm_Flatten((ideal)h->Data(),currRing);
res->rtyp=SMATRIX_CMD;
return FALSE;
}
else
WerrorS("smatrix expected");
}
else
/*==================== unflatten =============================*/
if(strcmp(sys_cmd,"unflatten")==0)
{
const short t1[]={2,SMATRIX_CMD,INT_CMD};
if (iiCheckTypes(h,t1,1))
{
res->data=(char*)sm_UnFlatten((ideal)h->Data(),(int)(long)h->next->Data(),currRing);
res->rtyp=SMATRIX_CMD;
return res->data==NULL;
}
else return TRUE;
}
else
/*==================== neworder =============================*/
if(strcmp(sys_cmd,"neworder")==0)
{
if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
{
res->rtyp=STRING_CMD;
res->data=(void *)singclap_neworder((ideal)h->Data(), currRing);
return FALSE;
}
else
WerrorS("ideal expected");
}
else
/*===== nc_hilb ===============================================*/
// Hilbert series of non-commutative monomial algebras
if(strcmp(sys_cmd,"nc_hilb") == 0)
{
ideal i; int lV;
bool ig = FALSE;
bool mgrad = FALSE;
bool autop = FALSE;
int trunDegHs=0;
if((h != NULL)&&(h->Typ() == IDEAL_CMD))
i = (ideal)h->Data();
else
{
WerrorS("nc_Hilb:ideal expected");
return TRUE;
}
h = h->next;
if((h != NULL)&&(h->Typ() == INT_CMD))
lV = (int)(long)h->Data();
else
{
WerrorS("nc_Hilb:int expected");
return TRUE;
}
h = h->next;
while(h != NULL)
{
if((int)(long)h->Data() == 1)
ig = TRUE;
else if((int)(long)h->Data() == 2)
mgrad = TRUE;
else if(h->Typ()==STRING_CMD)
autop = TRUE;
else if(h->Typ() == INT_CMD)
trunDegHs = (int)(long)h->Data();
h = h->next;
}
if(h != NULL)
{
WerrorS("nc_Hilb:int 1,2, total degree for the truncation, and a string for printing the details are expected");
return TRUE;
}
HilbertSeries_OrbitData(i, lV, ig, mgrad, autop, trunDegHs);
return(FALSE);
}
else
/* ====== verify ============================*/
if(strcmp(sys_cmd,"verifyGB")==0)
{
if (rIsNCRing(currRing))
{
WerrorS("system(\"verifyGB\",<ideal>,..) expects a commutative ring");
return TRUE;
}
if (((h->Typ()!=IDEAL_CMD)&&(h->Typ()!=MODUL_CMD))
|| (h->next!=NULL))
{
Werror("expected system(\"verifyGB\",<ideal/module>), found <%s>",Tok2Cmdname(h->Typ()));
return TRUE;
}
ideal F=(ideal)h->Data();
res->data=(char*)(long) kVerify(F,currRing->qideal);
res->rtyp=INT_CMD;
return FALSE;
}
else
/*===== rcolon ===============================================*/
if(strcmp(sys_cmd,"rcolon") == 0)
{
const short t1[]={3,IDEAL_CMD,POLY_CMD,INT_CMD};
if (iiCheckTypes(h,t1,1))
{
ideal i = (ideal)h->Data();
h = h->next;
poly w=(poly)h->Data();
h = h->next;
int lV = (int)(long)h->Data();
res->rtyp = IDEAL_CMD;
res->data = RightColonOperation(i, w, lV);
return(FALSE);
}
else
return TRUE;
}
else
/*==================== sh ==================================*/
if(strcmp(sys_cmd,"sh")==0)
{
if (FE_OPT_NO_SHELL_FLAG)
{
WerrorS("shell execution is disallowed in restricted mode");
return TRUE;
}
res->rtyp=INT_CMD;
if (h==NULL) res->data = (void *)(long) system("sh");
else if (h->Typ()==STRING_CMD)
res->data = (void*)(long) system((char*)(h->Data()));
else
WerrorS("string expected");
if (errno==ECHILD) res->data=NULL;
return FALSE;
}
else
/*========reduce procedure like the global one but with jet bounds=======*/
if(strcmp(sys_cmd,"reduce_bound")==0)
{
poly p=NULL;
ideal pid=NULL;
const short t1[]={3,POLY_CMD,IDEAL_CMD,INT_CMD};
const short t2[]={3,IDEAL_CMD,IDEAL_CMD,INT_CMD};
const short t3[]={3,VECTOR_CMD,MODUL_CMD,INT_CMD};
const short t4[]={3,MODUL_CMD,MODUL_CMD,INT_CMD};
if ((iiCheckTypes(h,t1,0))||((iiCheckTypes(h,t3,0))))
{
p = (poly)h->CopyD();
}
else if ((iiCheckTypes(h,t2,0))||(iiCheckTypes(h,t4,1)))
{
pid = (ideal)h->CopyD();
}
else return TRUE;
//int htype;
res->rtyp= h->Typ(); /*htype*/
ideal q = (ideal)h->next->CopyD();
int bound = (int)(long)h->next->next->Data();
if (pid==NULL) /*(htype == POLY_CMD || htype == VECTOR_CMD)*/
res->data = (char *)kNFBound(q,currRing->qideal,p,bound);
else /*(htype == IDEAL_CMD || htype == MODUL_CMD)*/
res->data = (char *)kNFBound(q,currRing->qideal,pid,bound);
return FALSE;
}
else
/*==================== uname ==================================*/
if(strcmp(sys_cmd,"uname")==0)
{
res->rtyp=STRING_CMD;
res->data = omStrDup(S_UNAME);
return FALSE;
}
else
/*==================== with ==================================*/
if(strcmp(sys_cmd,"with")==0)
{
if (h==NULL)
{
res->rtyp=STRING_CMD;
res->data=(void *)versionString();
return FALSE;
}
else if (h->Typ()==STRING_CMD)
{
#define TEST_FOR(A) if(strcmp(s,A)==0) res->data=(void *)1; else
char *s=(char *)h->Data();
res->rtyp=INT_CMD;
#ifdef HAVE_DBM
TEST_FOR("DBM")
#endif
#ifdef HAVE_DLD
TEST_FOR("DLD")
#endif
//TEST_FOR("factory")
//TEST_FOR("libfac")
#ifdef HAVE_READLINE
TEST_FOR("readline")
#endif
#ifdef TEST_MAC_ORDER
TEST_FOR("MAC_ORDER")
#endif
// unconditional since 3-1-0-6
TEST_FOR("Namespaces")
#ifdef HAVE_DYNAMIC_LOADING
TEST_FOR("DynamicLoading")
#endif
#ifdef HAVE_EIGENVAL
TEST_FOR("eigenval")
#endif
#ifdef HAVE_GMS
TEST_FOR("gms")
#endif
#ifdef OM_NDEBUG
TEST_FOR("om_ndebug")
#endif
#ifdef SING_NDEBUG
TEST_FOR("ndebug")
#endif
{};
return FALSE;
#undef TEST_FOR
}
return TRUE;
}
else
/*==================== browsers ==================================*/
if (strcmp(sys_cmd,"browsers")==0)
{
res->rtyp = STRING_CMD;
StringSetS("");
feStringAppendBrowsers(0);
res->data = StringEndS();
return FALSE;
}
else
/*==================== pid ==================================*/
if (strcmp(sys_cmd,"pid")==0)
{
res->rtyp=INT_CMD;
res->data=(void *)(long) getpid();
return FALSE;
}
else
/*==================== getenv ==================================*/
if (strcmp(sys_cmd,"getenv")==0)
{
if ((h!=NULL) && (h->Typ()==STRING_CMD))
{
res->rtyp=STRING_CMD;
const char *r=getenv((char *)h->Data());
if (r==NULL) r="";
res->data=(void *)omStrDup(r);
return FALSE;
}
else
{
WerrorS("string expected");
return TRUE;
}
}
else
/*==================== setenv ==================================*/
if (strcmp(sys_cmd,"setenv")==0)
{
#ifdef HAVE_SETENV
const short t[]={2,STRING_CMD,STRING_CMD};
if (iiCheckTypes(h,t,1))
{
res->rtyp=STRING_CMD;
setenv((char *)h->Data(), (char *)h->next->Data(), 1);
res->data=(void *)omStrDup((char *)h->next->Data());
feReInitResources();
return FALSE;
}
else
{
return TRUE;
}
#else
WerrorS("setenv not supported on this platform");
return TRUE;
#endif
}
else
/*==================== Singular ==================================*/
if (strcmp(sys_cmd, "Singular") == 0)
{
res->rtyp=STRING_CMD;
const char *r=feResource("Singular");
if (r == NULL) r="";
res->data = (void*) omStrDup( r );
return FALSE;
}
else
if (strcmp(sys_cmd, "SingularLib") == 0)
{
res->rtyp=STRING_CMD;
const char *r=feResource("SearchPath");
if (r == NULL) r="";
res->data = (void*) omStrDup( r );
return FALSE;
}
else
if (strcmp(sys_cmd, "SingularBin") == 0)
{
res->rtyp=STRING_CMD;
const char *r=feResource('r');
if (r == NULL) r="/usr/local";
int l=strlen(r);
/* where to find Singular's programs: */
#define SINGULAR_PROCS_DIR "/libexec/singular/MOD"
int ll=si_max((int)strlen(SINGULAR_PROCS_DIR),(int)strlen(LIBEXEC_DIR));
char *s=(char*)omAlloc(l+ll+2);
if ((strstr(r,".libs/..")==NULL) /*not installed Singular (libtool)*/
&&(strstr(r,"Singular/..")==NULL)) /*not installed Singular (static)*/
{
strcpy(s,r);
strcat(s,SINGULAR_PROCS_DIR);
if (access(s,X_OK)==0)
{
strcat(s,"/");
}
else
{
/*second try: LIBEXEC_DIR*/
strcpy(s,LIBEXEC_DIR);
if (access(s,X_OK)==0)
{
strcat(s,"/");
}
else
{
s[0]='\0';
}
}
}
else
{
const char *r=feResource('b');
if (r == NULL)
{
s[0]='\0';
}
else
{
strcpy(s,r);
strcat(s,"/");
}
}
res->data = (void*)s;
return FALSE;
}
else
/*==================== options ==================================*/
if (strstr(sys_cmd, "--") == sys_cmd)
{
if (strcmp(sys_cmd, "--") == 0)
{
fePrintOptValues();
return FALSE;
}
feOptIndex opt = feGetOptIndex(&sys_cmd[2]);
if (opt == FE_OPT_UNDEF)
{
Werror("Unknown option %s", sys_cmd);
WerrorS("Use 'system(\"--\");' for listing of available options");
return TRUE;
}
// for Untyped Options (help version),
// setting it just triggers action
if (feOptSpec[opt].type == feOptUntyped)
{
feSetOptValue(opt,0);
return FALSE;
}
if (h == NULL)
{
if (feOptSpec[opt].type == feOptString)
{
res->rtyp = STRING_CMD;
const char *r=(const char*)feOptSpec[opt].value;
if (r == NULL) r="";
res->data = omStrDup(r);
}
else
{
res->rtyp = INT_CMD;
res->data = feOptSpec[opt].value;
}
return FALSE;
}
const char* errormsg=NULL;
if (h->Typ() == INT_CMD)
{
if (feOptSpec[opt].type == feOptString)
{
Werror("Need string argument to set value of option %s", sys_cmd);
return TRUE;
}
errormsg = feSetOptValue(opt, (int)((long) h->Data()));
if (errormsg != NULL)
Werror("Option '--%s=%d' %s", sys_cmd, (int) ((long)h->Data()), errormsg);
}
else if (h->Typ()==STRING_CMD)
{
errormsg = feSetOptValue(opt, (char*) h->Data());
if (errormsg != NULL)
Werror("Option '--%s=%s' %s", sys_cmd, (char*) h->Data(), errormsg);
}
else
{
WerrorS("Need string or int argument to set option value");
return TRUE;
}
if (errormsg != NULL) return TRUE;
return FALSE;
}
else
/*==================== HC ==================================*/
if (strcmp(sys_cmd,"HC")==0)
{
res->rtyp=INT_CMD;
res->data=(void *)(long) HCord;
return FALSE;
}
else
/*==================== random ==================================*/
if(strcmp(sys_cmd,"random")==0)
{
const short t[]={1,INT_CMD};
if (h!=NULL)
{
if (iiCheckTypes(h,t,1))
{
siRandomStart=(int)((long)h->Data());
siSeed=siRandomStart;
factoryseed(siRandomStart);
return FALSE;
}
else
{
return TRUE;
}
}
res->rtyp=INT_CMD;
res->data=(void*)(long) siSeed;
return FALSE;
}
else
/*======================= demon_list =====================*/
if (strcmp(sys_cmd,"denom_list")==0)
{
res->rtyp=LIST_CMD;
extern lists get_denom_list();
res->data=(lists)get_denom_list();
return FALSE;
}
else
/*==================== complexNearZero ======================*/
if(strcmp(sys_cmd,"complexNearZero")==0)
{
const short t[]={2,NUMBER_CMD,INT_CMD};
if (iiCheckTypes(h,t,1))
{
if ( !rField_is_long_C(currRing) )
{
WerrorS( "unsupported ground field!");
return TRUE;
}
else
{
res->rtyp=INT_CMD;
res->data=(void*)complexNearZero((gmp_complex*)h->Data(),
(int)((long)(h->next->Data())));
return FALSE;
}
}
else
{
return TRUE;
}
}
else
/*==================== getPrecDigits ======================*/
if(strcmp(sys_cmd,"getPrecDigits")==0)
{
if ( (currRing==NULL)
|| (!rField_is_long_C(currRing) && !rField_is_long_R(currRing)))
{
WerrorS( "unsupported ground field!");
return TRUE;
}
res->rtyp=INT_CMD;
res->data=(void*)(long)gmp_output_digits;
//if (gmp_output_digits!=getGMPFloatDigits())
//{ Print("%d, %d\n",getGMPFloatDigits(),gmp_output_digits);}
return FALSE;
}
else
/*==================== lduDecomp ======================*/
if(strcmp(sys_cmd, "lduDecomp")==0)
{
const short t[]={1,MATRIX_CMD};
if (iiCheckTypes(h,t,1))
{
matrix aMat = (matrix)h->Data();
matrix pMat; matrix lMat; matrix dMat; matrix uMat;
poly l; poly u; poly prodLU;
lduDecomp(aMat, pMat, lMat, dMat, uMat, l, u, prodLU);
lists L = (lists)omAllocBin(slists_bin);
L->Init(7);
L->m[0].rtyp = MATRIX_CMD; L->m[0].data=(void*)pMat;
L->m[1].rtyp = MATRIX_CMD; L->m[1].data=(void*)lMat;
L->m[2].rtyp = MATRIX_CMD; L->m[2].data=(void*)dMat;
L->m[3].rtyp = MATRIX_CMD; L->m[3].data=(void*)uMat;
L->m[4].rtyp = POLY_CMD; L->m[4].data=(void*)l;
L->m[5].rtyp = POLY_CMD; L->m[5].data=(void*)u;
L->m[6].rtyp = POLY_CMD; L->m[6].data=(void*)prodLU;
res->rtyp = LIST_CMD;
res->data = (char *)L;
return FALSE;
}
else
{
return TRUE;
}
}
else
/*==================== lduSolve ======================*/
if(strcmp(sys_cmd, "lduSolve")==0)
{
/* for solving a linear equation system A * x = b, via the
given LDU-decomposition of the matrix A;
There is one valid parametrisation:
1) exactly eight arguments P, L, D, U, l, u, lTimesU, b;
P, L, D, and U realise the LDU-decomposition of A, that is,
P * A = L * D^(-1) * U, and P, L, D, and U satisfy the
properties decribed in method 'luSolveViaLDUDecomp' in
linearAlgebra.h; see there;
l, u, and lTimesU are as described in the same location;
b is the right-hand side vector of the linear equation system;
The method will return a list of either 1 entry or three entries:
1) [0] if there is no solution to the system;
2) [1, x, H] if there is at least one solution;
x is any solution of the given linear system,
H is the matrix with column vectors spanning the homogeneous
solution space.
The method produces an error if matrix and vector sizes do not
fit. */
const short t[]={7,MATRIX_CMD,MATRIX_CMD,MATRIX_CMD,MATRIX_CMD,POLY_CMD,POLY_CMD,MATRIX_CMD};
if (!iiCheckTypes(h,t,1))
{
return TRUE;
}
if (rField_is_Ring(currRing))
{
WerrorS("field required");
return TRUE;
}
matrix pMat = (matrix)h->Data();
matrix lMat = (matrix)h->next->Data();
matrix dMat = (matrix)h->next->next->Data();
matrix uMat = (matrix)h->next->next->next->Data();
poly l = (poly) h->next->next->next->next->Data();
poly u = (poly) h->next->next->next->next->next->Data();
poly lTimesU = (poly) h->next->next->next->next->next->next->Data();
matrix bVec = (matrix)h->next->next->next->next->next->next->next->Data();
matrix xVec; int solvable; matrix homogSolSpace;
if (pMat->rows() != pMat->cols())
{
Werror("first matrix (%d x %d) is not quadratic",
pMat->rows(), pMat->cols());
return TRUE;
}
if (lMat->rows() != lMat->cols())
{
Werror("second matrix (%d x %d) is not quadratic",
lMat->rows(), lMat->cols());
return TRUE;
}
if (dMat->rows() != dMat->cols())
{
Werror("third matrix (%d x %d) is not quadratic",
dMat->rows(), dMat->cols());
return TRUE;
}
if (dMat->cols() != uMat->rows())
{
Werror("third matrix (%d x %d) and fourth matrix (%d x %d) %s",
dMat->rows(), dMat->cols(), uMat->rows(), uMat->cols(),
"do not t");
return TRUE;
}
if (uMat->rows() != bVec->rows())
{
Werror("fourth matrix (%d x %d) and vector (%d x 1) do not fit",
uMat->rows(), uMat->cols(), bVec->rows());
return TRUE;
}
solvable = luSolveViaLDUDecomp(pMat, lMat, dMat, uMat, l, u, lTimesU,
bVec, xVec, homogSolSpace);
/* build the return structure; a list with either one or
three entries */
lists ll = (lists)omAllocBin(slists_bin);
if (solvable)
{
ll->Init(3);
ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)solvable;
ll->m[1].rtyp=MATRIX_CMD; ll->m[1].data=(void *)xVec;
ll->m[2].rtyp=MATRIX_CMD; ll->m[2].data=(void *)homogSolSpace;
}
else
{
ll->Init(1);
ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)solvable;
}
res->rtyp = LIST_CMD;
res->data=(char*)ll;
return FALSE;
}
else
/*==== countedref: reference and shared ====*/
if (strcmp(sys_cmd, "shared") == 0)
{
#ifndef SI_COUNTEDREF_AUTOLOAD
void countedref_shared_load();
countedref_shared_load();
#endif
res->rtyp = NONE;
return FALSE;
}
else if (strcmp(sys_cmd, "reference") == 0)
{
#ifndef SI_COUNTEDREF_AUTOLOAD
void countedref_reference_load();
countedref_reference_load();
#endif
res->rtyp = NONE;
return FALSE;
}
else
/*==================== semaphore =================*/
#ifdef HAVE_SIMPLEIPC
if (strcmp(sys_cmd,"semaphore")==0)
{
if((h!=NULL) && (h->Typ()==STRING_CMD) && (h->next!=NULL) && (h->next->Typ()==INT_CMD))
{
int v=1;
if ((h->next->next!=NULL)&& (h->next->next->Typ()==INT_CMD))
v=(int)(long)h->next->next->Data();
res->data=(char *)(long)simpleipc_cmd((char *)h->Data(),(int)(long)h->next->Data(),v);
res->rtyp=INT_CMD;
return FALSE;
}
else
{
WerrorS("Usage: system(\"semaphore\",<cmd>,int)");
return TRUE;
}
}
else
#endif
/*==================== reserved port =================*/
if (strcmp(sys_cmd,"reserve")==0)
{
const short t[]={1,INT_CMD};
if (iiCheckTypes(h,t,1))
{
res->rtyp=INT_CMD;
int p=ssiReservePort((int)(long)h->Data());
res->data=(void*)(long)p;
return (p==0);
}
return TRUE;
}
else
/*==================== reserved link =================*/
if (strcmp(sys_cmd,"reservedLink")==0)
{
res->rtyp=LINK_CMD;
si_link p=ssiCommandLink();
res->data=(void*)p;
return (p==NULL);
}
else
/*==================== install newstruct =================*/
if (strcmp(sys_cmd,"install")==0)
{
const short t[]={4,STRING_CMD,STRING_CMD,PROC_CMD,INT_CMD};
if (iiCheckTypes(h,t,1))
{
return newstruct_set_proc((char*)h->Data(),(char*)h->next->Data(),
(int)(long)h->next->next->next->Data(),
(procinfov)h->next->next->Data());
}
return TRUE;
}
else
/*==================== newstruct =================*/
if (strcmp(sys_cmd,"newstruct")==0)
{
const short t[]={1,STRING_CMD};
if (iiCheckTypes(h,t,1))
{
int id=0;
char *n=(char*)h->Data();
blackboxIsCmd(n,id);
if (id>0)
{
blackbox *bb=getBlackboxStuff(id);
if (BB_LIKE_LIST(bb))
{
newstruct_desc desc=(newstruct_desc)bb->data;
newstructShow(desc);
return FALSE;
}
else Werror("'%s' is not a newstruct",n);
}
else Werror("'%s' is not a blackbox object",n);
}
return TRUE;
}
else
/*==================== blackbox =================*/
if (strcmp(sys_cmd,"blackbox")==0)
{
printBlackboxTypes();
return FALSE;
}
else
/*================= absBiFact ======================*/
#if defined(HAVE_FLINT) || defined(HAVE_NTL)
if (strcmp(sys_cmd, "absFact") == 0)
{
const short t[]={1,POLY_CMD};
if (iiCheckTypes(h,t,1)
&& (currRing!=NULL)
&& (getCoeffType(currRing->cf)==n_transExt))
{
res->rtyp=LIST_CMD;
intvec *v=NULL;
ideal mipos= NULL;
int n= 0;
ideal f=singclap_absFactorize((poly)(h->Data()), mipos, &v, n, currRing);
if (f==NULL) return TRUE;
ivTest(v);
lists l=(lists)omAllocBin(slists_bin);
l->Init(4);
l->m[0].rtyp=IDEAL_CMD;
l->m[0].data=(void *)f;
l->m[1].rtyp=INTVEC_CMD;
l->m[1].data=(void *)v;
l->m[2].rtyp=IDEAL_CMD;
l->m[2].data=(void*) mipos;
l->m[3].rtyp=INT_CMD;
l->m[3].data=(void*) (long) n;
res->data=(void *)l;
return FALSE;
}
else return TRUE;
}
else
#endif
/* =================== LLL via NTL ==============================*/
#ifdef HAVE_NTL
if (strcmp(sys_cmd, "LLL") == 0)
{
if (h!=NULL)
{
res->rtyp=h->Typ();
if (h->Typ()==MATRIX_CMD)
{
res->data=(char *)singntl_LLL((matrix)h->Data(), currRing);
return FALSE;
}
else if (h->Typ()==INTMAT_CMD)
{
res->data=(char *)singntl_LLL((intvec*)h->Data());
return FALSE;
}
else return TRUE;
}
else return TRUE;
}
else
#endif
/* =================== LLL via Flint ==============================*/
#ifdef HAVE_FLINT
#if __FLINT_RELEASE >= 20500
if (strcmp(sys_cmd, "LLL_Flint") == 0)
{
if (h!=NULL)
{
if(h->next == NULL)
{
res->rtyp=h->Typ();
if (h->Typ()==BIGINTMAT_CMD)
{
res->data=(char *)singflint_LLL((bigintmat*)h->Data(), NULL);
return FALSE;
}
else if (h->Typ()==INTMAT_CMD)
{
res->data=(char *)singflint_LLL((intvec*)h->Data(), NULL);
return FALSE;
}
else return TRUE;
}
if(h->next->Typ()!= INT_CMD)
{
WerrorS("matrix,int or bigint,int expected");
return TRUE;
}
if(h->next->Typ()== INT_CMD)
{
if(((int)((long)(h->next->Data())) != 0) && (int)((long)(h->next->Data()) != 1))
{
WerrorS("int is different from 0, 1");
return TRUE;
}
res->rtyp=h->Typ();
if((long)(h->next->Data()) == 0)
{
if (h->Typ()==BIGINTMAT_CMD)
{
res->data=(char *)singflint_LLL((bigintmat*)h->Data(), NULL);
return FALSE;
}
else if (h->Typ()==INTMAT_CMD)
{
res->data=(char *)singflint_LLL((intvec*)h->Data(), NULL);
return FALSE;
}
else return TRUE;
}
// This will give also the transformation matrix U s.t. res = U * m
if((long)(h->next->Data()) == 1)
{
if (h->Typ()==BIGINTMAT_CMD)
{
bigintmat* m = (bigintmat*)h->Data();
bigintmat* T = new bigintmat(m->rows(),m->rows(),m->basecoeffs());
for(int i = 1; i<=m->rows(); i++)
{
n_Delete(&(BIMATELEM(*T,i,i)),T->basecoeffs());
BIMATELEM(*T,i,i)=n_Init(1, T->basecoeffs());
}
m = singflint_LLL(m,T);
lists L = (lists)omAllocBin(slists_bin);
L->Init(2);
L->m[0].rtyp = BIGINTMAT_CMD; L->m[0].data = (void*)m;
L->m[1].rtyp = BIGINTMAT_CMD; L->m[1].data = (void*)T;
res->data=L;
res->rtyp=LIST_CMD;
return FALSE;
}
else if (h->Typ()==INTMAT_CMD)
{
intvec* m = (intvec*)h->Data();
intvec* T = new intvec(m->rows(),m->rows(),(int)0);
for(int i = 1; i<=m->rows(); i++)
IMATELEM(*T,i,i)=1;
m = singflint_LLL(m,T);
lists L = (lists)omAllocBin(slists_bin);
L->Init(2);
L->m[0].rtyp = INTMAT_CMD; L->m[0].data = (void*)m;
L->m[1].rtyp = INTMAT_CMD; L->m[1].data = (void*)T;
res->data=L;
res->rtyp=LIST_CMD;
return FALSE;
}
else return TRUE;
}
}
}
else return TRUE;
}
else
#endif
#endif
/* ====== rref ============================*/
#if defined(HAVE_FLINT) || defined(HAVE_NTL)
if(strcmp(sys_cmd,"rref")==0)
{
const short t1[]={1,MATRIX_CMD};
const short t2[]={1,SMATRIX_CMD};
if (iiCheckTypes(h,t1,0))
{
matrix M=(matrix)h->Data();
#if defined(HAVE_FLINT)
res->data=(void*)singflint_rref(M,currRing);
#elif defined(HAVE_NTL)
res->data=(void*)singntl_rref(M,currRing);
#endif
res->rtyp=MATRIX_CMD;
return FALSE;
}
else if (iiCheckTypes(h,t2,1))
{
ideal M=(ideal)h->Data();
#if defined(HAVE_FLINT)
res->data=(void*)singflint_rref(M,currRing);
#elif defined(HAVE_NTL)
res->data=(void*)singntl_rref(M,currRing);
#endif
res->rtyp=SMATRIX_CMD;
return FALSE;
}
else
{
WerrorS("expected system(\"rref\",<matrix>/<smatrix>)");
return TRUE;
}
}
else
#endif
/*==================== pcv ==================================*/
#ifdef HAVE_PCV
if(strcmp(sys_cmd,"pcvLAddL")==0)
{
return pcvLAddL(res,h);
}
else
if(strcmp(sys_cmd,"pcvPMulL")==0)
{
return pcvPMulL(res,h);
}
else
if(strcmp(sys_cmd,"pcvMinDeg")==0)
{
return pcvMinDeg(res,h);
}
else
if(strcmp(sys_cmd,"pcvP2CV")==0)
{
return pcvP2CV(res,h);
}
else
if(strcmp(sys_cmd,"pcvCV2P")==0)
{
return pcvCV2P(res,h);
}
else
if(strcmp(sys_cmd,"pcvDim")==0)
{
return pcvDim(res,h);
}
else
if(strcmp(sys_cmd,"pcvBasis")==0)
{
return pcvBasis(res,h);
}
else
#endif
/*==================== hessenberg/eigenvalues ==================================*/
#ifdef HAVE_EIGENVAL
if(strcmp(sys_cmd,"hessenberg")==0)
{
return evHessenberg(res,h);
}
else
#endif
/*==================== eigenvalues ==================================*/
#ifdef HAVE_EIGENVAL
if(strcmp(sys_cmd,"eigenvals")==0)
{
return evEigenvals(res,h);
}
else
#endif
/*==================== rowelim ==================================*/
#ifdef HAVE_EIGENVAL
if(strcmp(sys_cmd,"rowelim")==0)
{
return evRowElim(res,h);
}
else
#endif
/*==================== rowcolswap ==================================*/
#ifdef HAVE_EIGENVAL
if(strcmp(sys_cmd,"rowcolswap")==0)
{
return evSwap(res,h);
}
else
#endif
/*==================== Gauss-Manin system ==================================*/
#ifdef HAVE_GMS
if(strcmp(sys_cmd,"gmsnf")==0)
{
return gmsNF(res,h);
}
else
#endif
/*==================== contributors =============================*/
if(strcmp(sys_cmd,"contributors") == 0)
{
res->rtyp=STRING_CMD;
res->data=(void *)omStrDup(
"Olaf Bachmann, Michael Brickenstein, Hubert Grassmann, Kai Krueger, Victor Levandovskyy, Wolfgang Neumann, Thomas Nuessler, Wilfred Pohl, Jens Schmidt, Mathias Schulze, Thomas Siebert, Ruediger Stobbe, Moritz Wenk, Tim Wichmann");
return FALSE;
}
else
/*==================== spectrum =============================*/
#ifdef HAVE_SPECTRUM
if(strcmp(sys_cmd,"spectrum") == 0)
{
if ((h==NULL) || (h->Typ()!=POLY_CMD))
{
WerrorS("poly expected");
return TRUE;
}
if (h->next==NULL)
return spectrumProc(res,h);
if (h->next->Typ()!=INT_CMD)
{
WerrorS("poly,int expected");
return TRUE;
}
if(((long)h->next->Data())==1L)
return spectrumfProc(res,h);
return spectrumProc(res,h);
}
else
/*==================== semic =============================*/
if(strcmp(sys_cmd,"semic") == 0)
{
if ((h->next!=NULL)
&& (h->Typ()==LIST_CMD)
&& (h->next->Typ()==LIST_CMD))
{
if (h->next->next==NULL)
return semicProc(res,h,h->next);
else if (h->next->next->Typ()==INT_CMD)
return semicProc3(res,h,h->next,h->next->next);
}
return TRUE;
}
else
/*==================== spadd =============================*/
if(strcmp(sys_cmd,"spadd") == 0)
{
const short t[]={2,LIST_CMD,LIST_CMD};
if (iiCheckTypes(h,t,1))
{
return spaddProc(res,h,h->next);
}
return TRUE;
}
else
/*==================== spmul =============================*/
if(strcmp(sys_cmd,"spmul") == 0)
{
const short t[]={2,LIST_CMD,INT_CMD};
if (iiCheckTypes(h,t,1))
{
return spmulProc(res,h,h->next);
}
return TRUE;
}
else
#endif
/*==================== tensorModuleMult ========================= */
#define HAVE_SHEAFCOH_TRICKS 1
#ifdef HAVE_SHEAFCOH_TRICKS
if(strcmp(sys_cmd,"tensorModuleMult")==0)
{
const short t[]={2,INT_CMD,MODUL_CMD};
// WarnS("tensorModuleMult!");
if (iiCheckTypes(h,t,1))
{
int m = (int)( (long)h->Data() );
ideal M = (ideal)h->next->Data();
res->rtyp=MODUL_CMD;
res->data=(void *)id_TensorModuleMult(m, M, currRing);
return FALSE;
}
return TRUE;
}
else
#endif
/*==================== twostd =================*/
#ifdef HAVE_PLURAL
if (strcmp(sys_cmd, "twostd") == 0)
{
ideal I;
if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
{
I=(ideal)h->CopyD();
res->rtyp=IDEAL_CMD;
if (rIsPluralRing(currRing)) res->data=twostd(I);
else res->data=I;
setFlag(res,FLAG_TWOSTD);
setFlag(res,FLAG_STD);
}
else return TRUE;
return FALSE;
}
else
#endif
/*==================== lie bracket =================*/
#ifdef HAVE_PLURAL
if (strcmp(sys_cmd, "bracket") == 0)
{
const short t[]={2,POLY_CMD,POLY_CMD};
if (iiCheckTypes(h,t,1))
{
poly p=(poly)h->CopyD();
h=h->next;
poly q=(poly)h->Data();
res->rtyp=POLY_CMD;
if (rIsPluralRing(currRing)) res->data=nc_p_Bracket_qq(p,q, currRing);
return FALSE;
}
return TRUE;
}
else
#endif
/*==================== env ==================================*/
#ifdef HAVE_PLURAL
if (strcmp(sys_cmd, "env")==0)
{
if ((h!=NULL) && (h->Typ()==RING_CMD))
{
ring r = (ring)h->Data();
res->data = rEnvelope(r);
res->rtyp = RING_CMD;
return FALSE;
}
else
{
WerrorS("`system(\"env\",<ring>)` expected");
return TRUE;
}
}
else
#endif
/* ============ opp ======================== */
#ifdef HAVE_PLURAL
if (strcmp(sys_cmd, "opp")==0)
{
if ((h!=NULL) && (h->Typ()==RING_CMD))
{
ring r=(ring)h->Data();
res->data=rOpposite(r);
res->rtyp=RING_CMD;
return FALSE;
}
else
{
WerrorS("`system(\"opp\",<ring>)` expected");
return TRUE;
}
}
else
#endif
/*==================== oppose ==================================*/
#ifdef HAVE_PLURAL
if (strcmp(sys_cmd, "oppose")==0)
{
if ((h!=NULL) && (h->Typ()==RING_CMD)
&& (h->next!= NULL))
{
ring Rop = (ring)h->Data();
h = h->next;
idhdl w;
if ((w=Rop->idroot->get(h->Name(),myynest))!=NULL)
{
poly p = (poly)IDDATA(w);
res->data = pOppose(Rop, p, currRing); // into CurrRing?
res->rtyp = POLY_CMD;
return FALSE;
}
}
else
{
WerrorS("`system(\"oppose\",<ring>,<poly>)` expected");
return TRUE;
}
}
else
#endif
/*==================== sat =================*/
if(strcmp(sys_cmd,"sat")==0)
{
ideal I= (ideal)h->Data();
ideal J=(ideal)h->next->Data();
int k;
ideal S=idSaturate_intern(I,J,k,h->Typ()==IDEAL_CMD,hasFlag(h,FLAG_STD));
res->rtyp=h->Typ();
res->data=(void*)S;
setFlag(res,FLAG_STD);
return FALSE;
}
else
/*==================== walk stuff =================*/
/*==================== walkNextWeight =================*/
#ifdef HAVE_WALK
#ifdef OWNW
if (strcmp(sys_cmd, "walkNextWeight") == 0)
{
const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->Data())->length() != currRing->N ||
((intvec*) h->next->Data())->length() != currRing->N)
{
Werror("system(\"walkNextWeight\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
res->data = (void*) walkNextWeight(((intvec*) h->Data()),
((intvec*) h->next->Data()),
(ideal) h->next->next->Data());
if (res->data == NULL || res->data == (void*) 1L)
{
res->rtyp = INT_CMD;
}
else
{
res->rtyp = INTVEC_CMD;
}
return FALSE;
}
else
#endif
#endif
/*==================== walkNextWeight =================*/
#ifdef HAVE_WALK
#ifdef OWNW
if (strcmp(sys_cmd, "walkInitials") == 0)
{
if (h == NULL || h->Typ() != IDEAL_CMD)
{
WerrorS("system(\"walkInitials\", ideal) expected");
return TRUE;
}
res->data = (void*) walkInitials((ideal) h->Data());
res->rtyp = IDEAL_CMD;
return FALSE;
}
else
#endif
#endif
/*==================== walkAddIntVec =================*/
#ifdef HAVE_WALK
#ifdef WAIV
if (strcmp(sys_cmd, "walkAddIntVec") == 0)
{
const short t[]={2,INTVEC_CMD,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
intvec* arg1 = (intvec*) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
res->data = (intvec*) walkAddIntVec(arg1, arg2);
res->rtyp = INTVEC_CMD;
return FALSE;
}
else
#endif
#endif
/*==================== MwalkNextWeight =================*/
#ifdef HAVE_WALK
#ifdef MwaklNextWeight
if (strcmp(sys_cmd, "MwalkNextWeight") == 0)
{
const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->Data())->length() != currRing->N ||
((intvec*) h->next->Data())->length() != currRing->N)
{
Werror("system(\"MwalkNextWeight\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
intvec* arg1 = (intvec*) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
ideal arg3 = (ideal) h->next->next->Data();
intvec* result = (intvec*) MwalkNextWeight(arg1, arg2, arg3);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif //MWalkNextWeight
#endif
/*==================== Mivdp =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "Mivdp") == 0)
{
if (h == NULL || h->Typ() != INT_CMD)
{
WerrorS("system(\"Mivdp\", int) expected");
return TRUE;
}
if ((int) ((long)(h->Data())) != currRing->N)
{
Werror("system(\"Mivdp\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
int arg1 = (int) ((long)(h->Data()));
intvec* result = (intvec*) Mivdp(arg1);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== Mivlp =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "Mivlp") == 0)
{
if (h == NULL || h->Typ() != INT_CMD)
{
WerrorS("system(\"Mivlp\", int) expected");
return TRUE;
}
if ((int) ((long)(h->Data())) != currRing->N)
{
Werror("system(\"Mivlp\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
int arg1 = (int) ((long)(h->Data()));
intvec* result = (intvec*) Mivlp(arg1);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MpDiv =================*/
#ifdef HAVE_WALK
#ifdef MpDiv
if(strcmp(sys_cmd, "MpDiv") == 0)
{
const short t[]={2,POLY_CMD,POLY_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
poly arg1 = (poly) h->Data();
poly arg2 = (poly) h->next->Data();
poly result = MpDiv(arg1, arg2);
res->rtyp = POLY_CMD;
res->data = result;
return FALSE;
}
else
#endif
#endif
/*==================== MpMult =================*/
#ifdef HAVE_WALK
#ifdef MpMult
if(strcmp(sys_cmd, "MpMult") == 0)
{
const short t[]={2,POLY_CMD,POLY_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
poly arg1 = (poly) h->Data();
poly arg2 = (poly) h->next->Data();
poly result = MpMult(arg1, arg2);
res->rtyp = POLY_CMD;
res->data = result;
return FALSE;
}
else
#endif
#endif
/*==================== MivSame =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "MivSame") == 0)
{
const short t[]={2,INTVEC_CMD,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
/*
if (((intvec*) h->Data())->length() != currRing->N ||
((intvec*) h->next->Data())->length() != currRing->N)
{
Werror("system(\"MivSame\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
*/
intvec* arg1 = (intvec*) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
/*
poly result = (poly) MivSame(arg1, arg2);
res->rtyp = POLY_CMD;
res->data = (poly) result;
*/
res->rtyp = INT_CMD;
res->data = (void*)(long) MivSame(arg1, arg2);
return FALSE;
}
else
#endif
/*==================== M3ivSame =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "M3ivSame") == 0)
{
const short t[]={3,INTVEC_CMD,INTVEC_CMD,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
/*
if (((intvec*) h->Data())->length() != currRing->N ||
((intvec*) h->next->Data())->length() != currRing->N ||
((intvec*) h->next->next->Data())->length() != currRing->N )
{
Werror("system(\"M3ivSame\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
*/
intvec* arg1 = (intvec*) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
/*
poly result = (poly) M3ivSame(arg1, arg2, arg3);
res->rtyp = POLY_CMD;
res->data = (poly) result;
*/
res->rtyp = INT_CMD;
res->data = (void*)(long) M3ivSame(arg1, arg2, arg3);
return FALSE;
}
else
#endif
/*==================== MwalkInitialForm =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "MwalkInitialForm") == 0)
{
const short t[]={2,IDEAL_CMD,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if(((intvec*) h->next->Data())->length() != currRing->N)
{
Werror("system \"MwalkInitialForm\"...) intvec not of length %d\n",
currRing->N);
return TRUE;
}
ideal id = (ideal) h->Data();
intvec* int_w = (intvec*) h->next->Data();
ideal result = (ideal) MwalkInitialForm(id, int_w);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MivMatrixOrder =================*/
#ifdef HAVE_WALK
/************** Perturbation walk **********/
if(strcmp(sys_cmd, "MivMatrixOrder") == 0)
{
if(h==NULL || h->Typ() != INTVEC_CMD)
{
WerrorS("system(\"MivMatrixOrder\",intvec) expected");
return TRUE;
}
intvec* arg1 = (intvec*) h->Data();
intvec* result = MivMatrixOrder(arg1);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MivMatrixOrderdp =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "MivMatrixOrderdp") == 0)
{
if(h==NULL || h->Typ() != INT_CMD)
{
WerrorS("system(\"MivMatrixOrderdp\",intvec) expected");
return TRUE;
}
int arg1 = (int) ((long)(h->Data()));
intvec* result = (intvec*) MivMatrixOrderdp(arg1);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MPertVectors =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "MPertVectors") == 0)
{
const short t[]={3,IDEAL_CMD,INTVEC_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
int arg3 = (int) ((long)(h->next->next->Data()));
intvec* result = (intvec*) MPertVectors(arg1, arg2, arg3);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MPertVectorslp =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "MPertVectorslp") == 0)
{
const short t[]={3,IDEAL_CMD,INTVEC_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
int arg3 = (int) ((long)(h->next->next->Data()));
intvec* result = (intvec*) MPertVectorslp(arg1, arg2, arg3);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/************** fractal walk **********/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "Mfpertvector") == 0)
{
const short t[]={2,IDEAL_CMD,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* result = Mfpertvector(arg1, arg2);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MivUnit =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "MivUnit") == 0)
{
const short t[]={1,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
int arg1 = (int) ((long)(h->Data()));
intvec* result = (intvec*) MivUnit(arg1);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MivWeightOrderlp =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "MivWeightOrderlp") == 0)
{
const short t[]={1,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
intvec* arg1 = (intvec*) h->Data();
intvec* result = MivWeightOrderlp(arg1);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MivWeightOrderdp =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "MivWeightOrderdp") == 0)
{
if(h==NULL || h->Typ() != INTVEC_CMD)
{
WerrorS("system(\"MivWeightOrderdp\",intvec) expected");
return TRUE;
}
intvec* arg1 = (intvec*) h->Data();
//int arg2 = (int) h->next->Data();
intvec* result = MivWeightOrderdp(arg1);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MivMatrixOrderlp =================*/
#ifdef HAVE_WALK
if(strcmp(sys_cmd, "MivMatrixOrderlp") == 0)
{
if(h==NULL || h->Typ() != INT_CMD)
{
WerrorS("system(\"MivMatrixOrderlp\",int) expected");
return TRUE;
}
int arg1 = (int) ((long)(h->Data()));
intvec* result = (intvec*) MivMatrixOrderlp(arg1);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MkInterRedNextWeight =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "MkInterRedNextWeight") == 0)
{
const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->Data())->length() != currRing->N ||
((intvec*) h->next->Data())->length() != currRing->N)
{
Werror("system(\"MkInterRedNextWeight\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
intvec* arg1 = (intvec*) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
ideal arg3 = (ideal) h->next->next->Data();
intvec* result = (intvec*) MkInterRedNextWeight(arg1, arg2, arg3);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MPertNextWeight =================*/
#ifdef HAVE_WALK
#ifdef MPertNextWeight
if (strcmp(sys_cmd, "MPertNextWeight") == 0)
{
const short t[]={3,INTVEC_CMD,IDEAL_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->Data())->length() != currRing->N)
{
Werror("system(\"MPertNextWeight\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
intvec* arg1 = (intvec*) h->Data();
ideal arg2 = (ideal) h->next->Data();
int arg3 = (int) h->next->next->Data();
intvec* result = (intvec*) MPertNextWeight(arg1, arg2, arg3);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif //MPertNextWeight
#endif
/*==================== Mivperttarget =================*/
#ifdef HAVE_WALK
#ifdef Mivperttarget
if (strcmp(sys_cmd, "Mivperttarget") == 0)
{
const short t[]={2,IDEAL_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
ideal arg1 = (ideal) h->Data();
int arg2 = (int) h->next->Data();
intvec* result = (intvec*) Mivperttarget(arg1, arg2);
res->rtyp = INTVEC_CMD;
res->data = result;
return FALSE;
}
else
#endif //Mivperttarget
#endif
/*==================== Mwalk =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "Mwalk") == 0)
{
const short t[]={6,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,RING_CMD,INT_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N )
{
Werror("system(\"Mwalk\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->CopyD();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
ring arg4 = (ring) h->next->next->next->Data();
int arg5 = (int) (long) h->next->next->next->next->Data();
int arg6 = (int) (long) h->next->next->next->next->next->Data();
ideal result = (ideal) Mwalk(arg1, arg2, arg3, arg4, arg5, arg6);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== Mpwalk =================*/
#ifdef HAVE_WALK
#ifdef MPWALK_ORIG
if (strcmp(sys_cmd, "Mwalk") == 0)
{
const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,RING_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if ((((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N ) &&
(((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N)))
{
Werror("system(\"Mwalk\" ...) intvecs not of length %d or %d\n",
currRing->N,(currRing->N)*(currRing->N));
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
ring arg4 = (ring) h->next->next->next->Data();
ideal result = (ideal) Mwalk(arg1, arg2, arg3,arg4);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#else
if (strcmp(sys_cmd, "Mpwalk") == 0)
{
const short t[]={8,IDEAL_CMD,INT_CMD,INT_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if(((intvec*) h->next->next->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->next->next->Data())->length()!=currRing->N)
{
Werror("system(\"Mpwalk\" ...) intvecs not of length %d\n",currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->Data();
int arg2 = (int) (long) h->next->Data();
int arg3 = (int) (long) h->next->next->Data();
intvec* arg4 = (intvec*) h->next->next->next->Data();
intvec* arg5 = (intvec*) h->next->next->next->next->Data();
int arg6 = (int) (long) h->next->next->next->next->next->Data();
int arg7 = (int) (long) h->next->next->next->next->next->next->Data();
int arg8 = (int) (long) h->next->next->next->next->next->next->next->Data();
ideal result = (ideal) Mpwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
#endif
/*==================== Mrwalk =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "Mrwalk") == 0)
{
const short t[]={7,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if(((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
((intvec*) h->next->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) )
{
Werror("system(\"Mrwalk\" ...) intvecs not of length %d or %d\n",
currRing->N,(currRing->N)*(currRing->N));
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
int arg4 = (int)(long) h->next->next->next->Data();
int arg5 = (int)(long) h->next->next->next->next->Data();
int arg6 = (int)(long) h->next->next->next->next->next->Data();
int arg7 = (int)(long) h->next->next->next->next->next->next->Data();
ideal result = (ideal) Mrwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MAltwalk1 =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "MAltwalk1") == 0)
{
const short t[]={5,IDEAL_CMD,INT_CMD,INT_CMD,INTVEC_CMD,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->next->next->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->next->next->Data())->length()!=currRing->N)
{
Werror("system(\"MAltwalk1\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->Data();
int arg2 = (int) ((long)(h->next->Data()));
int arg3 = (int) ((long)(h->next->next->Data()));
intvec* arg4 = (intvec*) h->next->next->next->Data();
intvec* arg5 = (intvec*) h->next->next->next->next->Data();
ideal result = (ideal) MAltwalk1(arg1, arg2, arg3, arg4, arg5);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MAltwalk1 =================*/
#ifdef HAVE_WALK
#ifdef MFWALK_ALT
if (strcmp(sys_cmd, "Mfwalk_alt") == 0)
{
const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N )
{
Werror("system(\"Mfwalk\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
int arg4 = (int) h->next->next->next->Data();
ideal result = (ideal) Mfwalk_alt(arg1, arg2, arg3, arg4);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
#endif
/*==================== Mfwalk =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "Mfwalk") == 0)
{
const short t[]={5,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N )
{
Werror("system(\"Mfwalk\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
int arg4 = (int)(long) h->next->next->next->Data();
int arg5 = (int)(long) h->next->next->next->next->Data();
ideal result = (ideal) Mfwalk(arg1, arg2, arg3, arg4, arg5);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== Mfrwalk =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "Mfrwalk") == 0)
{
const short t[]={6,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
/*
if (((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N)
{
Werror("system(\"Mfrwalk\" ...) intvecs not of length %d\n",currRing->N);
return TRUE;
}
*/
if((((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N ) &&
(((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
{
Werror("system(\"Mfrwalk\" ...) intvecs not of length %d or %d\n",
currRing->N,(currRing->N)*(currRing->N));
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
int arg4 = (int)(long) h->next->next->next->Data();
int arg5 = (int)(long) h->next->next->next->next->Data();
int arg6 = (int)(long) h->next->next->next->next->next->Data();
ideal result = (ideal) Mfrwalk(arg1, arg2, arg3, arg4, arg5, arg6);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
/*==================== Mprwalk =================*/
if (strcmp(sys_cmd, "Mprwalk") == 0)
{
const short t[]={9,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD,INT_CMD,INT_CMD,INT_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if((((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N ) &&
(((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
{
Werror("system(\"Mrwalk\" ...) intvecs not of length %d or %d\n",
currRing->N,(currRing->N)*(currRing->N));
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
int arg4 = (int)(long) h->next->next->next->Data();
int arg5 = (int)(long) h->next->next->next->next->Data();
int arg6 = (int)(long) h->next->next->next->next->next->Data();
int arg7 = (int)(long) h->next->next->next->next->next->next->Data();
int arg8 = (int)(long) h->next->next->next->next->next->next->next->Data();
int arg9 = (int)(long) h->next->next->next->next->next->next->next->next->Data();
ideal result = (ideal) Mprwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== TranMImprovwalk =================*/
#ifdef HAVE_WALK
#ifdef TRAN_Orig
if (strcmp(sys_cmd, "TranMImprovwalk") == 0)
{
const short t[]={3,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N )
{
Werror("system(\"TranMImprovwalk\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
ideal result = (ideal) TranMImprovwalk(arg1, arg2, arg3);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
#endif
/*==================== MAltwalk2 =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "MAltwalk2") == 0)
{
const short t[]={3,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N )
{
Werror("system(\"MAltwalk2\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
ideal result = (ideal) MAltwalk2(arg1, arg2, arg3);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== MAltwalk2 =================*/
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "TranMImprovwalk") == 0)
{
const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD};
if (!iiCheckTypes(h,t,1)) return TRUE;
if (((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N )
{
Werror("system(\"TranMImprovwalk\" ...) intvecs not of length %d\n",
currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
int arg4 = (int) ((long)(h->next->next->next->Data()));
ideal result = (ideal) TranMImprovwalk(arg1, arg2, arg3, arg4);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
/*==================== TranMrImprovwalk =================*/
#if 0
#ifdef HAVE_WALK
if (strcmp(sys_cmd, "TranMrImprovwalk") == 0)
{
if (h == NULL || h->Typ() != IDEAL_CMD ||
h->next == NULL || h->next->Typ() != INTVEC_CMD ||
h->next->next == NULL || h->next->next->Typ() != INTVEC_CMD ||
h->next->next->next == NULL || h->next->next->next->Typ() != INT_CMD ||
h->next->next->next == NULL || h->next->next->next->next->Typ() != INT_CMD ||
h->next->next->next == NULL || h->next->next->next->next->next->Typ() != INT_CMD)
{
WerrorS("system(\"TranMrImprovwalk\", ideal, intvec, intvec) expected");
return TRUE;
}
if (((intvec*) h->next->Data())->length() != currRing->N &&
((intvec*) h->next->next->Data())->length() != currRing->N )
{
Werror("system(\"TranMrImprovwalk\" ...) intvecs not of length %d\n", currRing->N);
return TRUE;
}
ideal arg1 = (ideal) h->Data();
intvec* arg2 = (intvec*) h->next->Data();
intvec* arg3 = (intvec*) h->next->next->Data();
int arg4 = (int)(long) h->next->next->next->Data();
int arg5 = (int)(long) h->next->next->next->next->Data();
int arg6 = (int)(long) h->next->next->next->next->next->Data();
ideal result = (ideal) TranMrImprovwalk(arg1, arg2, arg3, arg4, arg5, arg6);
res->rtyp = IDEAL_CMD;
res->data = result;
return FALSE;
}
else
#endif
#endif
/*================= Extended system call ========================*/
{
#ifndef MAKE_DISTRIBUTION
return(jjEXTENDED_SYSTEM(res, args));
#else
Werror( "system(\"%s\",...) %s", sys_cmd, feNotImplemented );
#endif
}
} /* typ==string */
return TRUE;
}
BIMATELEM
#define BIMATELEM(M, I, J)
Definition bigintmat.h:133
printBlackboxTypes
void printBlackboxTypes()
list all defined type (for debugging)
Definition blackbox.cc:236
m
int m
Definition cfEzgcd.cc:128
bound
static CanonicalForm bound(const CFMatrix &M)
Definition cf_linsys.cc:460
factoryseed
void factoryseed(int s)
random seed initializer
Definition cf_random.cc:186
f
FILE * f
Definition checklibs.c:9
singntl_rref
matrix singntl_rref(matrix m, const ring R)
Definition clapsing.cc:2051
singntl_LLL
matrix singntl_LLL(matrix m, const ring s)
Definition clapsing.cc:1969
singclap_absFactorize
ideal singclap_absFactorize(poly f, ideal &mipos, intvec **exps, int &numFactors, const ring r)
Definition clapsing.cc:2157
singclap_neworder
char * singclap_neworder(ideal I, const ring r)
Definition clapsing.cc:1711
gmp_complex
gmp_complex numbers based on
Definition mpr_complex.h:181
siRandomStart
VAR int siRandomStart
Definition cntrlc.cc:99
n_transExt
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
nCoeff_is_Ring
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition coeffs.h:732
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition coeffs.h:431
n_Init
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition coeffs.h:541
countedref_reference_load
void countedref_reference_load()
Initialize blackbox types 'reference' and 'shared', or both.
Definition countedref.cc:700
countedref_shared_load
void countedref_shared_load()
Definition countedref.cc:724
get_denom_list
lists get_denom_list()
Definition denom_list.cc:8
evRowElim
matrix evRowElim(matrix M, int i, int j, int k)
Definition eigenval.cc:47
evHessenberg
matrix evHessenberg(matrix M)
Definition eigenval.cc:100
evSwap
matrix evSwap(matrix M, int i, int j)
Definition eigenval.cc:25
evEigenvals
lists evEigenvals(matrix M)
Definition eigenval_ip.cc:120
FE_OPT_NO_SHELL_FLAG
EXTERN_VAR BOOLEAN FE_OPT_NO_SHELL_FLAG
Definition extra.cc:166
SINGULAR_PROCS_DIR
#define SINGULAR_PROCS_DIR
TEST_FOR
#define TEST_FOR(A)
jjEXTENDED_SYSTEM
static BOOLEAN jjEXTENDED_SYSTEM(leftv res, leftv h)
Definition extra.cc:2382
result
return result
Definition facAbsBiFact.cc:76
feOptIndex
feOptIndex
Definition feOptGen.h:15
FE_OPT_UNDEF
@ FE_OPT_UNDEF
Definition feOptGen.h:15
fePrintOptValues
void fePrintOptValues()
Definition feOpt.cc:344
feGetOptIndex
feOptIndex feGetOptIndex(const char *name)
Definition feOpt.cc:104
feSetOptValue
const char * feSetOptValue(feOptIndex opt, char *optarg)
Definition feOpt.cc:154
feOptValue
static void * feOptValue(feOptIndex opt)
Definition feOpt.h:40
feOptSpec
EXTERN_VAR struct fe_option feOptSpec[]
Definition feOpt.h:17
feReInitResources
void feReInitResources()
Definition feResource.cc:182
feResource
static char * feResource(feResourceConfig config, int warn)
Definition feResource.cc:233
getenv
char * getenv()
feOptUntyped
@ feOptUntyped
Definition fegetopt.h:77
feOptString
@ feOptString
Definition fegetopt.h:77
feStringAppendBrowsers
void feStringAppendBrowsers(int warn)
Definition fehelp.cc:341
singflint_rref
matrix singflint_rref(matrix m, const ring R)
singflint_LLL
bigintmat * singflint_LLL(bigintmat *A, bigintmat *T)
gmsNF
lists gmsNF(ideal p, ideal g, matrix B, int D, int K)
Definition gms.cc:22
HilbertSeries_OrbitData
void HilbertSeries_OrbitData(ideal S, int lV, bool IG_CASE, bool mgrad, bool odp, int trunDegHs)
Definition hilb.cc:770
RightColonOperation
ideal RightColonOperation(ideal S, poly w, int lV)
Definition hilb.cc:1117
idSaturate_intern
ideal idSaturate_intern(ideal I, ideal J, int &k, BOOLEAN isIdeal, BOOLEAN isSB)
Definition ideals.cc:3495
id_TensorModuleMult
ideal id_TensorModuleMult(const int m, const ideal M, const ring rRing)
Definition simpleideals.cc:2067
ivTest
#define ivTest(v)
Definition intvec.h:172
setFlag
#define setFlag(A, F)
Definition ipid.h:113
FLAG_TWOSTD
#define FLAG_TWOSTD
Definition ipid.h:107
FLAG_STD
#define FLAG_STD
Definition ipid.h:106
spaddProc
BOOLEAN spaddProc(leftv result, leftv first, leftv second)
Definition ipshell.cc:4431
semicProc3
BOOLEAN semicProc3(leftv res, leftv u, leftv v, leftv w)
Definition ipshell.cc:4514
spectrumfProc
BOOLEAN spectrumfProc(leftv result, leftv first)
Definition ipshell.cc:4187
spmulProc
BOOLEAN spmulProc(leftv result, leftv first, leftv second)
Definition ipshell.cc:4473
spectrumProc
BOOLEAN spectrumProc(leftv result, leftv first)
Definition ipshell.cc:4136
semicProc
BOOLEAN semicProc(leftv res, leftv u, leftv v)
Definition ipshell.cc:4554
versionString
char * versionString()
Definition misc_ip.cc:769
T
STATIC_VAR jList * T
Definition janet.cc:30
kNFBound
poly kNFBound(ideal F, ideal Q, poly p, int bound, int syzComp, int lazyReduce)
Definition kstd1.cc:3285
kVerify
BOOLEAN kVerify(ideal F, ideal Q)
Definition kverify.cc:367
HCord
VAR int HCord
Definition kutil.cc:239
pOppose
poly pOppose(ring Rop_src, poly p, const ring Rop_dst)
opposes a vector p from Rop to currRing (dst!)
Definition old.gring.cc:3324
nc_p_Bracket_qq
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
Definition old.gring.cc:2251
luSolveViaLDUDecomp
bool luSolveViaLDUDecomp(const matrix pMat, const matrix lMat, const matrix dMat, const matrix uMat, const poly l, const poly u, const poly lTimesU, const matrix bVec, matrix &xVec, matrix &H)
Solves the linear system A * x = b, where A is an (m x n)-matrix which is given by its LDU-decomposit...
Definition linearAlgebra.cc:1470
lduDecomp
void lduDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &dMat, matrix &uMat, poly &l, poly &u, poly &lTimesU)
LU-decomposition of a given (m x n)-matrix with performing only those divisions that yield zero remai...
Definition linearAlgebra.cc:1352
sm_UnFlatten
ideal sm_UnFlatten(ideal a, int col, const ring R)
Definition matpol.cc:1942
sm_Flatten
ideal sm_Flatten(ideal a, const ring R)
Definition matpol.cc:1922
SINGULAR_VERSION
#define SINGULAR_VERSION
Definition mod2.h:87
gmp_output_digits
EXTERN_VAR size_t gmp_output_digits
Definition mpr_base.h:115
complexNearZero
bool complexNearZero(gmp_complex *c, int digits)
Definition mpr_complex.cc:754
twostd
ideal twostd(ideal I)
Compute two-sided GB:
Definition nc.cc:18
newstructShow
void newstructShow(newstruct_desc d)
Definition newstruct.cc:837
newstruct_set_proc
BOOLEAN newstruct_set_proc(const char *bbname, const char *func, int args, procinfov pr)
Definition newstruct.cc:857
omFindExec
char * omFindExec(const char *name, char *exec)
Definition omFindExec.c:315
MAXPATHLEN
#define MAXPATHLEN
Definition omRet2Info.c:22
p_Content
void p_Content(poly ph, const ring r)
Definition p_polys.cc:2343
p_Cleardenom
poly p_Cleardenom(poly p, const ring r)
Definition p_polys.cc:2893
pcvP2CV
poly pcvP2CV(poly p, int d0, int d1)
Definition pcv.cc:280
pcvBasis
int pcvBasis(lists b, int i, poly m, int d, int n)
Definition pcv.cc:430
pcvMinDeg
int pcvMinDeg(poly p)
Definition pcv.cc:135
pcvDim
int pcvDim(int d0, int d1)
Definition pcv.cc:400
pcvPMulL
lists pcvPMulL(poly p, lists l1)
Definition pcv.cc:76
pcvCV2P
poly pcvCV2P(poly cv, int d0, int d1)
Definition pcv.cc:297
pcvLAddL
lists pcvLAddL(lists l1, lists l2)
Definition pcv.cc:31
StringSetS
void StringSetS(const char *st)
Definition reporter.cc:128
feNotImplemented
const char feNotImplemented[]
Definition reporter.cc:54
StringEndS
char * StringEndS()
Definition reporter.cc:151
rOpposite
ring rOpposite(ring src)
Definition ring.cc:5425
rEnvelope
ring rEnvelope(ring R)
Definition ring.cc:5819
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406
rField_is_long_C
static BOOLEAN rField_is_long_C(const ring r)
Definition ring.h:551
rBlocks
static int rBlocks(const ring r)
Definition ring.h:574
rIsNCRing
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:427
rField_is_long_R
static BOOLEAN rField_is_long_R(const ring r)
Definition ring.h:548
rField_is_Ring
#define rField_is_Ring(R)
Definition ring.h:491
simpleipc_cmd
int simpleipc_cmd(char *cmd, int id, int v)
Definition semaphore.c:167
siSeed
VAR int siSeed
Definition sirandom.c:30
M
#define M
Definition sirandom.c:25
ssiCommandLink
si_link ssiCommandLink()
Definition ssiLink.cc:3194
ssiReservePort
int ssiReservePort(int clients)
Definition ssiLink.cc:3158
M3ivSame
int M3ivSame(intvec *temp, intvec *u, intvec *v)
Definition walk.cc:915
MivWeightOrderdp
intvec * MivWeightOrderdp(intvec *ivstart)
Definition walk.cc:1457
MivUnit
intvec * MivUnit(int nV)
Definition walk.cc:1497
TranMImprovwalk
ideal TranMImprovwalk(ideal G, intvec *curr_weight, intvec *target_tmp, int nP)
Definition walk.cc:8397
MivMatrixOrderdp
intvec * MivMatrixOrderdp(int nV)
Definition walk.cc:1418
Mfwalk
ideal Mfwalk(ideal G, intvec *ivstart, intvec *ivtarget, int reduction, int printout)
Definition walk.cc:8032
MPertVectors
intvec * MPertVectors(ideal G, intvec *ivtarget, int pdeg)
Definition walk.cc:1089
MivWeightOrderlp
intvec * MivWeightOrderlp(intvec *ivstart)
Definition walk.cc:1437
Mprwalk
ideal Mprwalk(ideal Go, intvec *orig_M, intvec *target_M, int weight_rad, int op_deg, int tp_deg, int nP, int reduction, int printout)
Definition walk.cc:6389
MivMatrixOrder
intvec * MivMatrixOrder(intvec *iv)
Definition walk.cc:964
MAltwalk2
ideal MAltwalk2(ideal Go, intvec *curr_weight, intvec *target_weight)
Definition walk.cc:4281
MAltwalk1
ideal MAltwalk1(ideal Go, int op_deg, int tp_deg, intvec *curr_weight, intvec *target_weight)
Definition walk.cc:9672
Mrwalk
ideal Mrwalk(ideal Go, intvec *orig_M, intvec *target_M, int weight_rad, int pert_deg, int reduction, int printout)
Definition walk.cc:5604
Mfrwalk
ideal Mfrwalk(ideal G, intvec *ivstart, intvec *ivtarget, int weight_rad, int reduction, int printout)
Definition walk.cc:8213
Mwalk
ideal Mwalk(ideal Go, intvec *orig_M, intvec *target_M, ring baseRing, int reduction, int printout)
Definition walk.cc:5303
Mpwalk
ideal Mpwalk(ideal Go, int op_deg, int tp_deg, intvec *curr_weight, intvec *target_weight, int nP, int reduction, int printout)
Definition walk.cc:5948
MivSame
int MivSame(intvec *u, intvec *v)
Definition walk.cc:894
Mivlp
intvec * Mivlp(int nR)
Definition walk.cc:1023
MwalkInitialForm
ideal MwalkInitialForm(ideal G, intvec *ivw)
Definition walk.cc:762
MivMatrixOrderlp
intvec * MivMatrixOrderlp(int nV)
Definition walk.cc:1402
Mfpertvector
intvec * Mfpertvector(ideal G, intvec *ivtarget)
Definition walk.cc:1513
MPertVectorslp
intvec * MPertVectorslp(ideal G, intvec *ivtarget, int pdeg)
Definition walk.cc:1300
Mivdp
intvec * Mivdp(int nR)
Definition walk.cc:1008
MkInterRedNextWeight
intvec * MkInterRedNextWeight(intvec *iva, intvec *ivb, ideal G)
Definition walk.cc:2571
MwalkNextWeight
intvec * MwalkNextWeight(intvec *curr_weight, intvec *target_weight, ideal G)
Mivperttarget
intvec * Mivperttarget(ideal G, int ndeg)
MPertNextWeight
intvec * MPertNextWeight(intvec *iva, ideal G, int deg)

## jjVARIABLES_ID()

BOOLEAN jjVARIABLES_ID | ( | leftv | res,
|  | leftv | u )

Definition at line 6318 of file ipshell.cc.

{
int *e=(int *)omAlloc0((rVar(currRing)+1)*sizeof(int));
ideal I=(ideal)u->Data();
int i;
int n=0;
for(i=I->nrows*I->ncols-1;i>=0;i--)
{
int n0=pGetVariables(I->m[i],e);
if (n0>n) n=n0;
}
jjINT_S_TO_ID(n,e,res);
return FALSE;
}
jjINT_S_TO_ID
static void jjINT_S_TO_ID(int n, int *e, leftv res)
Definition ipshell.cc:6288
omAlloc0
#define omAlloc0(size)
Definition omAllocDecl.h:211
pGetVariables
#define pGetVariables(p, e)
Definition polys.h:252

## jjVARIABLES_P()

BOOLEAN jjVARIABLES_P | ( | leftv | res,
|  | leftv | u )

Definition at line 6310 of file ipshell.cc.

{
int *e=(int *)omAlloc0((rVar(currRing)+1)*sizeof(int));
int n=pGetVariables((poly)u->Data(),e);
jjINT_S_TO_ID(n,e,res);
return FALSE;
}

## killlocals()

void killlocals | ( | int | v | ) |

Definition at line 387 of file ipshell.cc.

{
BOOLEAN changed=FALSE;
idhdl sh=currRingHdl;
ring cr=currRing;
if (sh!=NULL) changed=((IDLEV(sh)<v) || (IDRING(sh)->ref>0));
//if (changed) Print("currRing=%s(%x), lev=%d,ref=%d\n",IDID(sh),IDRING(sh),IDLEV(sh),IDRING(sh)->ref);
killlocals_rec(&(basePack->idroot),v,currRing);
if (iiRETURNEXPR_len > myynest)
{
int t=iiRETURNEXPR.Typ();
if (/*iiRETURNEXPR.Typ()*/ t==RING_CMD)
{
leftv h=&iiRETURNEXPR;
if (((ring)h->data)->idroot!=NULL)
killlocals0(v,&(((ring)h->data)->idroot),(ring)h->data);
}
else if (/*iiRETURNEXPR.Typ()*/ t==LIST_CMD)
{
leftv h=&iiRETURNEXPR;
changed |=killlocals_list(v,(lists)h->data);
}
}
if (changed)
{
currRingHdl=rFindHdl(cr,NULL);
if (currRingHdl==NULL)
currRing=NULL;
else if(cr!=currRing)
rChangeCurrRing(cr);
}
if (myynest<=1) iiNoKeepRing=TRUE;
//Print("end killlocals >= %d\n",v);
//listall();
}
iiRETURNEXPR_len
VAR int iiRETURNEXPR_len
Definition iplib.cc:484
killlocals_list
BOOLEAN killlocals_list(int v, lists L)
Definition ipshell.cc:367
iiNoKeepRing
STATIC_VAR BOOLEAN iiNoKeepRing
Definition ipshell.cc:85
killlocals_rec
void killlocals_rec(idhdl *root, int v, ring r)
Definition ipshell.cc:331
killlocals0
static void killlocals0(int v, idhdl *localhdl, const ring r)
Definition ipshell.cc:296

## kQHWeight()

BOOLEAN kQHWeight | ( | leftv | res,
|  | leftv | v )

Definition at line 3325 of file ipshell.cc.

{
res->data=(char *)id_QHomWeight((ideal)v->Data(), currRing);
if (res->data==NULL)
res->data=(char *)new intvec(rVar(currRing));
return FALSE;
}
id_QHomWeight
intvec * id_QHomWeight(ideal id, const ring r)
Definition simpleideals.cc:1917

## kWeight()

BOOLEAN kWeight | ( | leftv | res,
|  | leftv | id )

Definition at line 3297 of file ipshell.cc.

{
ideal F=(ideal)id->Data();
intvec * iv = new intvec(rVar(currRing));
polyset s;
int sl, n, i;
int *x;
res->data=(char *)iv;
s = F->m;
sl = IDELEMS(F) - 1;
n = rVar(currRing);
if (sl==-1)
{
for(int i=0;i<n;i++) (*iv)[i]=1;
return FALSE;
}
double wNsqr = (double)2.0 / (double)n;
wFunctional = wFunctionalBuch;
x = (int * )omAlloc(2 * (n + 1) * sizeof(int));
wCall(s, sl, x, wNsqr, currRing);
for (i = n; i!=0; i--)
(*iv)[i-1] = x[i + n + 1];
omFreeSize((ADDRESS)x, 2 * (n + 1) * sizeof(int));
return FALSE;
}
x
Variable x
Definition cfModGcd.cc:4090
wFunctional
THREAD_VAR double(* wFunctional)(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
Definition weight.cc:20
wCall
void wCall(poly *s, int sl, int *x, double wNsqr, const ring R)
Definition weight.cc:108
wFunctionalBuch
double wFunctionalBuch(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
Definition weight0.cc:78

## list_cmd()

void list_cmd | ( | int | typ,
|  | const char * | what,
|  | const char * | prefix,
|  | BOOLEAN | iterate,
|  | BOOLEAN | fullname = FALSE )

Definition at line 426 of file ipshell.cc.

{
package savePack=currPack;
idhdl h,start;
BOOLEAN all = typ<0;
BOOLEAN really_all=FALSE;
if ( typ==0 )
{
if (strcmp(what,"all")==0)
{
if (currPack!=basePack)
list_cmd(-1,NULL,prefix,iterate,fullname); // list current package
really_all=TRUE;
h=basePack->idroot;
}
else
{
h = ggetid(what);
if (h!=NULL)
{
if (iterate) list1(prefix,h,TRUE,fullname);
if (IDTYP(h)==ALIAS_CMD) PrintS("A");
if (IDTYP(h)==RING_CMD)
{
h=IDRING(h)->idroot;
}
else if(IDTYP(h)==PACKAGE_CMD)
{
currPack=IDPACKAGE(h);
//Print("list_cmd:package\n");
all=TRUE;typ=PROC_CMD;fullname=TRUE;really_all=TRUE;
h=IDPACKAGE(h)->idroot;
}
else
{
currPack=savePack;
return;
}
}
else
{
Werror("%s is undefined",what);
currPack=savePack;
return;
}
}
all=TRUE;
}
else if (RingDependend(typ))
{
h = currRing->idroot;
}
else
h = IDROOT;
start=h;
while (h!=NULL)
{
if ((all
&& (IDTYP(h)!=PROC_CMD)
&&(IDTYP(h)!=PACKAGE_CMD)
&&(IDTYP(h)!=CRING_CMD)
)
|| (typ == IDTYP(h))
|| ((IDTYP(h)==CRING_CMD) && (typ==RING_CMD))
)
{
list1(prefix,h,start==currRingHdl, fullname);
if ((IDTYP(h)==RING_CMD)
&& (really_all || (all && (h==currRingHdl)))
&& ((IDLEV(h)==0)||(IDLEV(h)==myynest)))
{
list_cmd(0,IDID(h),"// ",FALSE);
}
if (IDTYP(h)==PACKAGE_CMD && really_all)
{
package save_p=currPack;
currPack=IDPACKAGE(h);
list_cmd(0,IDID(h),"// ",FALSE);
currPack=save_p;
}
}
h = IDNEXT(h);
}
currPack=savePack;
}
IDNEXT
#define IDNEXT(a)
Definition ipid.h:118
list_cmd
void list_cmd(int typ, const char *what, const char *prefix, BOOLEAN iterate, BOOLEAN fullname)
Definition ipshell.cc:426
list1
static void list1(const char *s, idhdl h, BOOLEAN c, BOOLEAN fullname)
Definition ipshell.cc:150

## loNewtonP()

BOOLEAN loNewtonP | ( | leftv | res,
|  | leftv | arg1 )

compute Newton Polytopes of input polynomials

Definition at line 4566 of file ipshell.cc.

{
res->data= (void*)loNewtonPolytope( (ideal)arg1->Data() );
return FALSE;
}
loNewtonPolytope
ideal loNewtonPolytope(const ideal id)
Definition mpr_base.cc:3191

## loSimplex()

BOOLEAN loSimplex | ( | leftv | res,
|  | leftv | args )

Implementation of the Simplex Algorithm.

For args, see class simplex.

Definition at line 4572 of file ipshell.cc.

{
if ( !(rField_is_long_R(currRing)) )
{
WerrorS("Ground field not implemented!");
return TRUE;
}
simplex * LP;
matrix m;
leftv v= args;
if ( v->Typ() != MATRIX_CMD ) // 1: matrix
return TRUE;
else
m= (matrix)(v->CopyD());
LP = new simplex(MATROWS(m),MATCOLS(m));
LP->mapFromMatrix(m);
v= v->next;
if ( v->Typ() != INT_CMD ) // 2: m = number of constraints
return TRUE;
else
LP->m= (int)(long)(v->Data());
v= v->next;
if ( v->Typ() != INT_CMD ) // 3: n = number of variables
return TRUE;
else
LP->n= (int)(long)(v->Data());
v= v->next;
if ( v->Typ() != INT_CMD ) // 4: m1 = number of <= constraints
return TRUE;
else
LP->m1= (int)(long)(v->Data());
v= v->next;
if ( v->Typ() != INT_CMD ) // 5: m2 = number of >= constraints
return TRUE;
else
LP->m2= (int)(long)(v->Data());
v= v->next;
if ( v->Typ() != INT_CMD ) // 6: m3 = number of == constraints
return TRUE;
else
LP->m3= (int)(long)(v->Data());
#ifdef mprDEBUG_PROT
Print("m (constraints) %d\n",LP->m);
Print("n (columns) %d\n",LP->n);
Print("m1 (<=) %d\n",LP->m1);
Print("m2 (>=) %d\n",LP->m2);
Print("m3 (==) %d\n",LP->m3);
#endif
LP->compute();
lists lres= (lists)omAlloc( sizeof(slists) );
lres->Init( 6 );
lres->m[0].rtyp= MATRIX_CMD; // output matrix
lres->m[0].data=(void*)LP->mapToMatrix(m);
lres->m[1].rtyp= INT_CMD; // found a solution?
lres->m[1].data=(void*)(long)LP->icase;
lres->m[2].rtyp= INTVEC_CMD;
lres->m[2].data=(void*)LP->posvToIV();
lres->m[3].rtyp= INTVEC_CMD;
lres->m[3].data=(void*)LP->zrovToIV();
lres->m[4].rtyp= INT_CMD;
lres->m[4].data=(void*)(long)LP->m;
lres->m[5].rtyp= INT_CMD;
lres->m[5].data=(void*)(long)LP->n;
res->data= (void*)lres;
return FALSE;
}
simplex
Linear Programming / Linear Optimization using Simplex - Algorithm.
Definition mpr_numeric.h:195
simplex::zrovToIV
intvec * zrovToIV()
Definition mpr_numeric.cc:1084
simplex::m1
int m1
Definition mpr_numeric.h:200
simplex::n
int n
Definition mpr_numeric.h:199
simplex::m2
int m2
Definition mpr_numeric.h:200
simplex::mapFromMatrix
BOOLEAN mapFromMatrix(matrix m)
Definition mpr_numeric.cc:1011
simplex::icase
int icase
Definition mpr_numeric.h:201
simplex::compute
void compute()
Definition mpr_numeric.cc:1095
simplex::m3
int m3
Definition mpr_numeric.h:200
simplex::m
int m
Definition mpr_numeric.h:198
simplex::mapToMatrix
matrix mapToMatrix(matrix m)
Definition mpr_numeric.cc:1040
simplex::posvToIV
intvec * posvToIV()
Definition mpr_numeric.cc:1073
slists
Definition lists.h:24
MATROWS
#define MATROWS(i)
Definition matpol.h:26
MATCOLS
#define MATCOLS(i)
Definition matpol.h:27

## mpJacobi()

BOOLEAN mpJacobi | ( | leftv | res,
|  | leftv | a )

Definition at line 3064 of file ipshell.cc.

{
int i,j;
matrix result;
ideal id=(ideal)a->Data();
result =mpNew(IDELEMS(id),rVar(currRing));
for (i=1; i<=IDELEMS(id); i++)
{
for (j=1; j<=rVar(currRing); j++)
{
MATELEM(result,i,j) = pDiff(id->m[i-1],j);
}
}
res->data=(char *)result;
return FALSE;
}
MATELEM
#define MATELEM(mat, i, j)
1-based access to matrix
Definition matpol.h:29
pDiff
#define pDiff(a, b)
Definition polys.h:297

## mpKoszul()

BOOLEAN mpKoszul | ( | leftv | res,
|  | leftv | c,
|  | leftv | b,
|  | leftv | id )

Definition at line 3086 of file ipshell.cc.

{
int n=(int)(long)b->Data();
int d=(int)(long)c->Data();
int k,l,sign,row,col;
matrix result;
ideal temp;
BOOLEAN bo;
poly p;
if ((d>n) || (d<1) || (n<1))
{
res->data=(char *)mpNew(1,1);
return FALSE;
}
int *choise = (int*)omAlloc(d*sizeof(int));
if (id==NULL)
temp=idMaxIdeal(1);
else
temp=(ideal)id->Data();
k = binom(n,d);
l = k*d;
l /= n-d+1;
result =mpNew(l,k);
col = 1;
idInitChoise(d,1,n,&bo,choise);
while (!bo)
{
sign = 1;
for (l=1;l<=d;l++)
{
if (choise[l-1]<=IDELEMS(temp))
{
p = pCopy(temp->m[choise[l-1]-1]);
if (sign == -1) p = pNeg(p);
sign *= -1;
row = idGetNumberOfChoise(l-1,d,1,n,choise);
MATELEM(result,row,col) = p;
}
}
col++;
idGetNextChoise(d,n,&bo,choise);
}
omFreeSize(choise,d*sizeof(int));
if (id==NULL) idDelete(&temp);
res->data=(char *)result;
return FALSE;
}
binom
int binom(int n, int r)
Definition simpleideals.cc:1212
idGetNextChoise
void idGetNextChoise(int r, int end, BOOLEAN *endch, int *choise)
Definition simpleideals.cc:1154
idMaxIdeal
#define idMaxIdeal(D)
initialise the maximal ideal (at 0)
Definition ideals.h:33
idGetNumberOfChoise
int idGetNumberOfChoise(int t, int d, int begin, int end, int *choise)
Definition simpleideals.cc:1180
idInitChoise
void idInitChoise(int r, int beg, int end, BOOLEAN *endch, int *choise)
Definition simpleideals.cc:1132
pNeg
#define pNeg(p)
Definition polys.h:199
pCopy
#define pCopy(p)
return a copy of the poly
Definition polys.h:186
sign
static int sign(int x)
Definition ring.cc:3504

## nuLagSolve()

BOOLEAN nuLagSolve | ( | leftv | res,
|  | leftv | arg1,
|  | leftv | arg2,
|  | leftv | arg3 )

find the (complex) roots an univariate polynomial Determines the roots of an univariate polynomial using Laguerres' root-solver.

Good for polynomials with low and middle degree (<40). Arguments 3: poly arg1 , int arg2 , int arg3 arg2>0: defines precision of fractional part if ground field is Q arg3: number of iterations for approximation of roots (default=2) Returns a list of all (complex) roots of the polynomial arg1

Definition at line 4681 of file ipshell.cc.

{
poly gls;
gls= (poly)(arg1->Data());
int howclean= (int)(long)arg3->Data();
if ( gls == NULL || pIsConstant( gls ) )
{
WerrorS("Input polynomial is constant!");
return TRUE;
}
if (rField_is_Zp(currRing))
{
int* r=Zp_roots(gls, currRing);
lists rlist;
rlist= (lists)omAlloc( sizeof(slists) );
rlist->Init( r[0] );
for(int i=r[0];i>0;i--)
{
rlist->m[i-1].data=n_Init(r[i],currRing->cf);
rlist->m[i-1].rtyp=NUMBER_CMD;
}
omFree(r);
res->data=rlist;
res->rtyp= LIST_CMD;
return FALSE;
}
if ( !(rField_is_R(currRing) ||
rField_is_Q(currRing) ||
rField_is_long_R(currRing) ||
rField_is_long_C(currRing)) )
{
WerrorS("Ground field not implemented!");
return TRUE;
}
if ( !(rField_is_R(currRing) || rField_is_long_R(currRing) || \
rField_is_long_C(currRing)) )
{
unsigned long int ii = (unsigned long int)arg2->Data();
setGMPFloatDigits( ii, ii );
}
int ldummy;
int deg= currRing->pLDeg( gls, &ldummy, currRing );
int i,vpos=0;
poly piter;
lists elist;
elist= (lists)omAlloc( sizeof(slists) );
elist->Init( 0 );
if ( rVar(currRing) > 1 )
{
piter= gls;
for ( i= 1; i <= rVar(currRing); i++ )
if ( pGetExp( piter, i ) )
{
vpos= i;
break;
}
while ( piter )
{
for ( i= 1; i <= rVar(currRing); i++ )
if ( (vpos != i) && (pGetExp( piter, i ) != 0) )
{
WerrorS("The input polynomial must be univariate!");
return TRUE;
}
pIter( piter );
}
}
rootContainer * roots= new rootContainer();
number * pcoeffs= (number *)omAlloc( (deg+1) * sizeof( number ) );
piter= gls;
for ( i= deg; i >= 0; i-- )
{
if ( piter && pTotaldegree(piter) == i )
{
pcoeffs[i]= nCopy( pGetCoeff( piter ) );
//nPrint( pcoeffs[i] );PrintS(" ");
pIter( piter );
}
else
{
pcoeffs[i]= nInit(0);
}
}
#ifdef mprDEBUG_PROT
for (i=deg; i >= 0; i--)
{
nPrint( pcoeffs[i] );PrintS(" ");
}
PrintLn();
#endif
roots->fillContainer( pcoeffs, NULL, 1, deg, rootContainer::onepoly, 1 );
roots->solver( howclean );
int elem= roots->getAnzRoots();
char *dummy;
int j;
lists rlist;
rlist= (lists)omAlloc( sizeof(slists) );
rlist->Init( elem );
if (rField_is_long_C(currRing))
{
for ( j= 0; j < elem; j++ )
{
rlist->m[j].rtyp=NUMBER_CMD;
rlist->m[j].data=(void *)nCopy((number)(roots->getRoot(j)));
//rlist->m[j].data=(void *)(number)(roots->getRoot(j));
}
}
else
{
for ( j= 0; j < elem; j++ )
{
dummy = complexToStr( (*roots)[j], gmp_output_digits, currRing->cf );
rlist->m[j].rtyp=STRING_CMD;
rlist->m[j].data=(void *)dummy;
}
}
elist->Clean();
//omFreeSize( (ADDRESS) elist, sizeof(slists) );
// this is (via fillContainer) the same data as in root
//for ( i= deg; i >= 0; i-- ) nDelete( &pcoeffs[i] );
//omFreeSize( (ADDRESS) pcoeffs, (deg+1) * sizeof( number ) );
delete roots;
res->data= (void*)rlist;
return FALSE;
}
Zp_roots
int * Zp_roots(poly p, const ring r)
Definition clapsing.cc:2242
rootContainer
complex root finder for univariate polynomials based on laguers algorithm
Definition mpr_numeric.h:66
rootContainer::getRoot
gmp_complex * getRoot(const int i)
Definition mpr_numeric.h:88
rootContainer::fillContainer
void fillContainer(number *_coeffs, number *_ievpoint, const int _var, const int _tdg, const rootType _rt, const int _anz)
Definition mpr_numeric.cc:300
rootContainer::onepoly
@ onepoly
Definition mpr_numeric.h:68
rootContainer::getAnzRoots
int getAnzRoots()
Definition mpr_numeric.h:97
rootContainer::solver
bool solver(const int polishmode=PM_NONE)
Definition mpr_numeric.cc:437
pIter
#define pIter(p)
Definition monomials.h:37
complexToStr
char * complexToStr(gmp_complex &c, const unsigned int oprec, const coeffs src)
Definition mpr_complex.cc:693
setGMPFloatDigits
void setGMPFloatDigits(size_t digits, size_t rest)
Set size of mantissa digits - the number of output digits (basis 10) the size of mantissa consists of...
Definition mpr_complex.cc:60
nCopy
#define nCopy(n)
Definition numbers.h:15
nPrint
#define nPrint(a)
only for debug, over any initialized currRing
Definition numbers.h:46
pIsConstant
#define pIsConstant(p)
like above, except that Comp must be 0
Definition polys.h:239
rField_is_R
static BOOLEAN rField_is_R(const ring r)
Definition ring.h:524
rField_is_Zp
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:506
rField_is_Q
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:512

## nuMPResMat()

BOOLEAN nuMPResMat | ( | leftv | res,
|  | leftv | arg1,
|  | leftv | arg2 )

returns module representing the multipolynomial resultant matrix Arguments 2: ideal i, int k k=0: use sparse resultant matrix of Gelfand, Kapranov and Zelevinsky k=1: use resultant matrix of Macaulay (k=0 is default)

Definition at line 4658 of file ipshell.cc.

{
ideal gls = (ideal)(arg1->Data());
int imtype= (int)(long)arg2->Data();
uResultant::resMatType mtype= determineMType( imtype );
// check input ideal ( = polynomial system )
if ( mprIdealCheck( gls, arg1->Name(), mtype, true ) != mprOk )
{
return TRUE;
}
uResultant *resMat= new uResultant( gls, mtype, false );
if (resMat!=NULL)
{
res->rtyp = MODUL_CMD;
res->data= (void*)resMat->accessResMat()->getMatrix();
if (!errorreported) delete resMat;
}
return errorreported;
}
resMatrixBase::getMatrix
virtual ideal getMatrix()
Definition mpr_base.h:31
uResultant
Base class for solving 0-dim poly systems using u-resultant.
Definition mpr_base.h:63
uResultant::resMatType
resMatType
Definition mpr_base.h:65
uResultant::accessResMat
resMatrixBase * accessResMat()
Definition mpr_base.h:78
mprOk
@ mprOk
Definition mpr_base.h:98
determineMType
uResultant::resMatType determineMType(int imtype)
mprIdealCheck
mprState mprIdealCheck(const ideal theIdeal, const char *name, uResultant::resMatType mtype, BOOLEAN rmatrix=false)

## nuUResSolve()

BOOLEAN nuUResSolve | ( | leftv | res,
|  | leftv | args )

solve a multipolynomial system using the u-resultant Input ideal must be 0-dimensional and (currRing->N) == IDELEMS(ideal).

Resultant method can be MPR_DENSE, which uses Macaulay Resultant (good for dense homogeneous polynoms) or MPR_SPARSE, which uses Sparse Resultant (Gelfand, Kapranov, Zelevinsky). Arguments 4: ideal i, int k, int l, int m k=0: use sparse resultant matrix of Gelfand, Kapranov and Zelevinsky k=1: use resultant matrix of Macaulay (k=0 is default) l>0: defines precision of fractional part if ground field is Q m=0,1,2: number of iterations for approximation of roots (default=2) Returns a list containing the roots of the system.

Definition at line 4925 of file ipshell.cc.

{
leftv v= args;
ideal gls;
int imtype;
int howclean;
// get ideal
if ( v->Typ() != IDEAL_CMD )
return TRUE;
else gls= (ideal)(v->Data());
v= v->next;
// get resultant matrix type to use (0,1)
if ( v->Typ() != INT_CMD )
return TRUE;
else imtype= (int)(long)v->Data();
v= v->next;
if (imtype==0)
{
ideal test_id=idInit(1,1);
int j;
for(j=IDELEMS(gls)-1;j>=0;j--)
{
if (gls->m[j]!=NULL)
{
test_id->m[0]=gls->m[j];
intvec *dummy_w=id_QHomWeight(test_id, currRing);
if (dummy_w!=NULL)
{
WerrorS("Newton polytope not of expected dimension");
delete dummy_w;
return TRUE;
}
}
}
}
// get and set precision in digits ( > 0 )
if ( v->Typ() != INT_CMD )
return TRUE;
else if ( !(rField_is_R(currRing) || rField_is_long_R(currRing) || \
rField_is_long_C(currRing)) )
{
unsigned long int ii=(unsigned long int)v->Data();
setGMPFloatDigits( ii, ii );
}
v= v->next;
// get interpolation steps (0,1,2)
if ( v->Typ() != INT_CMD )
return TRUE;
else howclean= (int)(long)v->Data();
uResultant::resMatType mtype= determineMType( imtype );
int i,count;
lists listofroots= NULL;
number smv= NULL;
BOOLEAN interpolate_det= (mtype==uResultant::denseResMat)?TRUE:FALSE;
//emptylist= (lists)omAlloc( sizeof(slists) );
//emptylist->Init( 0 );
//res->rtyp = LIST_CMD;
//res->data= (void *)emptylist;
// check input ideal ( = polynomial system )
if ( mprIdealCheck( gls, args->Name(), mtype ) != mprOk )
{
return TRUE;
}
uResultant * ures;
rootContainer ** iproots;
rootContainer ** muiproots;
rootArranger * arranger;
// main task 1: setup of resultant matrix
ures= new uResultant( gls, mtype );
if ( ures->accessResMat()->initState() != resMatrixBase::ready )
{
WerrorS("Error occurred during matrix setup!");
return TRUE;
}
// if dense resultant, check if minor nonsingular
if ( mtype == uResultant::denseResMat )
{
smv= ures->accessResMat()->getSubDet();
#ifdef mprDEBUG_PROT
PrintS("// Determinant of submatrix: ");nPrint(smv);PrintLn();
#endif
if ( nIsZero(smv) )
{
WerrorS("Unsuitable input ideal: Minor of resultant matrix is singular!");
return TRUE;
}
}
// main task 2: Interpolate specialized resultant polynomials
if ( interpolate_det )
iproots= ures->interpolateDenseSP( false, smv );
else
iproots= ures->specializeInU( false, smv );
// main task 3: Interpolate specialized resultant polynomials
if ( interpolate_det )
muiproots= ures->interpolateDenseSP( true, smv );
else
muiproots= ures->specializeInU( true, smv );
#ifdef mprDEBUG_PROT
int c= iproots[0]->getAnzElems();
for (i=0; i < c; i++) pWrite(iproots[i]->getPoly());
c= muiproots[0]->getAnzElems();
for (i=0; i < c; i++) pWrite(muiproots[i]->getPoly());
#endif
// main task 4: Compute roots of specialized polys and match them up
arranger= new rootArranger( iproots, muiproots, howclean );
arranger->solve_all();
// get list of roots
if ( arranger->success() )
{
arranger->arrange();
listofroots= listOfRoots(arranger, gmp_output_digits );
}
else
{
WerrorS("Solver was unable to find any roots!");
return TRUE;
}
// free everything
count= iproots[0]->getAnzElems();
for (i=0; i < count; i++) delete iproots[i];
omFreeSize( (ADDRESS) iproots, count * sizeof(rootContainer*) );
count= muiproots[0]->getAnzElems();
for (i=0; i < count; i++) delete muiproots[i];
omFreeSize( (ADDRESS) muiproots, count * sizeof(rootContainer*) );
delete ures;
delete arranger;
if (smv!=NULL) nDelete( &smv );
res->data= (void *)listofroots;
//emptylist->Clean();
// omFreeSize( (ADDRESS) emptylist, sizeof(slists) );
return FALSE;
}
resMatrixBase::getSubDet
virtual number getSubDet()
Definition mpr_base.h:37
resMatrixBase::ready
@ ready
Definition mpr_base.h:26
resMatrixBase::initState
virtual IStateType initState() const
Definition mpr_base.h:41
rootArranger
Definition mpr_numeric.h:150
rootArranger::solve_all
void solve_all()
Definition mpr_numeric.cc:858
rootArranger::success
bool success()
Definition mpr_numeric.h:162
rootArranger::arrange
void arrange()
Definition mpr_numeric.cc:883
rootContainer::getAnzElems
int getAnzElems()
Definition mpr_numeric.h:95
uResultant::specializeInU
rootContainer ** specializeInU(BOOLEAN matchUp=false, const number subDetVal=NULL)
Definition mpr_base.cc:3060
uResultant::interpolateDenseSP
rootContainer ** interpolateDenseSP(BOOLEAN matchUp=false, const number subDetVal=NULL)
Definition mpr_base.cc:2922
uResultant::denseResMat
@ denseResMat
Definition mpr_base.h:65
listOfRoots
lists listOfRoots(rootArranger *self, const unsigned int oprec)
Definition ipshell.cc:5082
nIsZero
#define nIsZero(n)
Definition numbers.h:19
pWrite
void pWrite(poly p)
Definition polys.h:309
count
int status int void size_t count
Definition si_signals.h:69

## nuVanderSys()

BOOLEAN nuVanderSys | ( | leftv | res,
|  | leftv | arg1,
|  | leftv | arg2,
|  | leftv | arg3 )

COMPUTE: polynomial p with values given by v at points p1,..,pN derived from p; more precisely: consider p as point in K^n and v as N elements in K, let p1,..,pN be the points in K^n obtained by evaluating all monomials of degree 0,1,...,N at p in lexicographical order, then the procedure computes the polynomial f satisfying f(pi) = v[i] RETURN: polynomial f of degree d.

Definition at line 4824 of file ipshell.cc.

{
int i;
ideal p,w;
p= (ideal)arg1->Data();
w= (ideal)arg2->Data();
// w[0] = f(p^0)
// w[1] = f(p^1)
// ...
// p can be a vector of numbers (multivariate polynom)
// or one number (univariate polynom)
// tdg = deg(f)
int n= IDELEMS( p );
int m= IDELEMS( w );
int tdg= (int)(long)arg3->Data();
res->data= (void*)NULL;
// check the input
if ( tdg < 1 )
{
WerrorS("Last input parameter must be > 0!");
return TRUE;
}
if ( n != rVar(currRing) )
{
Werror("Size of first input ideal must be equal to %d!",rVar(currRing));
return TRUE;
}
if ( m != (int)pow((double)tdg+1,(double)n) )
{
Werror("Size of second input ideal must be equal to %d!",
(int)pow((double)tdg+1,(double)n));
return TRUE;
}
if ( !(rField_is_Q(currRing) /* ||
rField_is_R() || rField_is_long_R() ||
rField_is_long_C()*/ ) )
{
WerrorS("Ground field not implemented!");
return TRUE;
}
number tmp;
number *pevpoint= (number *)omAlloc( n * sizeof( number ) );
for ( i= 0; i < n; i++ )
{
pevpoint[i]=nInit(0);
if ( (p->m)[i] )
{
tmp = pGetCoeff( (p->m)[i] );
if ( nIsZero(tmp) || nIsOne(tmp) || nIsMOne(tmp) )
{
omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
WerrorS("Elements of first input ideal must not be equal to -1, 0, 1!");
return TRUE;
}
} else tmp= NULL;
if ( !nIsZero(tmp) )
{
if ( !pIsConstant((p->m)[i]))
{
omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
WerrorS("Elements of first input ideal must be numbers!");
return TRUE;
}
pevpoint[i]= nCopy( tmp );
}
}
number *wresults= (number *)omAlloc( m * sizeof( number ) );
for ( i= 0; i < m; i++ )
{
wresults[i]= nInit(0);
if ( (w->m)[i] && !nIsZero(pGetCoeff((w->m)[i])) )
{
if ( !pIsConstant((w->m)[i]))
{
omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
omFreeSize( (ADDRESS)wresults, m * sizeof( number ) );
WerrorS("Elements of second input ideal must be numbers!");
return TRUE;
}
wresults[i]= nCopy(pGetCoeff((w->m)[i]));
}
}
vandermonde vm( m, n, tdg, pevpoint, FALSE );
number *ncpoly= vm.interpolateDense( wresults );
// do not free ncpoly[]!!
poly rpoly= vm.numvec2poly( ncpoly );
omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
omFreeSize( (ADDRESS)wresults, m * sizeof( number ) );
res->data= (void*)rpoly;
return FALSE;
}
pow
Rational pow(const Rational &a, int e)
Definition GMPrat.cc:411
vandermonde
vandermonde system solver for interpolating polynomials from their values
Definition mpr_numeric.h:29
nIsMOne
#define nIsMOne(n)
Definition numbers.h:26
nIsOne
#define nIsOne(n)
Definition numbers.h:25

## paPrint()

void paPrint | ( | const char * | n,
|  | package | p )

Definition at line 6333 of file ipshell.cc.

{
Print(" %s (",n);
switch (p->language)
{
case LANG_SINGULAR: PrintS("S"); break;
case LANG_C: PrintS("C"); break;
case LANG_TOP: PrintS("T"); break;
case LANG_MAX: PrintS("M"); break;
case LANG_NONE: PrintS("N"); break;
default: PrintS("U");
}
if(p->libname!=NULL)
Print(",%s", p->libname);
PrintS(")");
}
LANG_MAX
@ LANG_MAX
Definition subexpr.h:22
LANG_TOP
@ LANG_TOP
Definition subexpr.h:22

## rCompose()

ring rCompose | ( | const lists | L,
|  | const BOOLEAN | check_comp = TRUE,
|  | const long | bitmask = 0x7fff,
|  | const int | isLetterplace = FALSE )

Definition at line 2782 of file ipshell.cc.

{
if ((L->nr!=3)
#ifdef HAVE_PLURAL
&&(L->nr!=5)
#endif
)
return NULL;
int is_gf_char=0;
// 0: char/ cf - ring
// 1: list (var)
// 2: list (ord)
// 3: qideal
// possibly:
// 4: C
// 5: D
ring R = (ring) omAlloc0Bin(sip_sring_bin);
// ------------------------------------------------------------------
// 0: char:
if (L->m[0].Typ()==CRING_CMD)
{
R->cf=(coeffs)L->m[0].Data();
R->cf->ref++;
}
else if (L->m[0].Typ()==INT_CMD)
{
int ch = (int)(long)L->m[0].Data();
assume( ch >= 0 );
if (ch == 0) // Q?
R->cf = nInitChar(n_Q, NULL);
else
{
int l = IsPrime(ch); // Zp?
if( l != ch )
{
Warn("%d is invalid characteristic of ground field. %d is used.", ch, l);
ch = l;
}
#ifndef TEST_ZN_AS_ZP
R->cf = nInitChar(n_Zp, (void*)(long)ch);
#else
mpz_t modBase;
mpz_init_set_ui(modBase,(long) ch);
ZnmInfo info;
info.base= modBase;
info.exp= 1;
R->cf=nInitChar(n_Zn,(void*) &info); //exponent is missing
R->cf->is_field=1;
R->cf->is_domain=1;
R->cf->has_simple_Inverse=1;
#endif
}
}
else if (L->m[0].Typ()==LIST_CMD) // something complicated...
{
lists LL=(lists)L->m[0].Data();
if (LL->m[0].Typ() == STRING_CMD) // 1st comes a string?
{
rComposeRing(LL, R); // Ring!?
}
else
if (LL->nr < 3)
rComposeC(LL,R); // R, long_R, long_C
else
{
if (LL->m[0].Typ()==INT_CMD)
{
int ch = (int)(long)LL->m[0].Data();
while ((ch!=fftable[is_gf_char]) && (fftable[is_gf_char])) is_gf_char++;
if (fftable[is_gf_char]==0) is_gf_char=-1;
if(is_gf_char!= -1)
{
GFInfo param;
param.GFChar = ch;
param.GFDegree = 1;
param.GFPar_name = (const char*)(((lists)(LL->m[1].Data()))->m[0].Data());
// nfInitChar should be able to handle the case when ch is in fftables!
R->cf = nInitChar(n_GF, (void*)&param);
}
}
if( R->cf == NULL )
{
ring extRing = rCompose((lists)L->m[0].Data(),FALSE,0x7fff);
if (extRing==NULL)
{
WerrorS("could not create the specified coefficient field");
goto rCompose_err;
}
if( extRing->qideal != NULL ) // Algebraic extension
{
AlgExtInfo extParam;
extParam.r = extRing;
R->cf = nInitChar(n_algExt, (void*)&extParam);
}
else // Transcendental extension
{
TransExtInfo extParam;
extParam.r = extRing;
R->cf = nInitChar(n_transExt, &extParam);
}
//rDecRefCnt(R);
}
}
}
else
{
WerrorS("coefficient field must be described by `int` or `list`");
goto rCompose_err;
}
if( R->cf == NULL )
{
WerrorS("could not create coefficient field described by the input!");
goto rCompose_err;
}
// ------------------------- VARS ---------------------------
if (rComposeVar(L,R)) goto rCompose_err;
// ------------------------ ORDER ------------------------------
if (rComposeOrder(L,check_comp,R)) goto rCompose_err;
// ------------------------ ??????? --------------------
if (!isLetterplace) rRenameVars(R);
#ifdef HAVE_SHIFTBBA
else
{
R->isLPring=isLetterplace;
R->ShortOut=FALSE;
R->CanShortOut=FALSE;
}
#endif
if ((bitmask!=0)&&(R->wanted_maxExp==0)) R->wanted_maxExp=bitmask;
rComplete(R);
// ------------------------ Q-IDEAL ------------------------
if (L->m[3].Typ()==IDEAL_CMD)
{
ideal q=(ideal)L->m[3].Data();
if ((q!=NULL) && (q->m!=NULL) && (q->m[0]!=NULL))
{
if (R->cf != currRing->cf) //->cf->ch!=currRing->cf->ch)
{
#if 0
WerrorS("coefficient fields must be equal if q-ideal !=0");
goto rCompose_err;
#else
ring orig_ring=currRing;
rChangeCurrRing(R);
int *perm=NULL;
int *par_perm=NULL;
int par_perm_size=0;
nMapFunc nMap;
if ((nMap=nSetMap(orig_ring->cf))==NULL)
{
if (rEqual(orig_ring,currRing))
{
nMap=n_SetMap(currRing->cf, currRing->cf);
}
else
// Allow imap/fetch to be make an exception only for:
if ( (rField_is_Q_a(orig_ring) && // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
(rField_is_Q(currRing) || rField_is_Q_a(currRing) ||
rField_is_Zp(currRing) || rField_is_Zp_a(currRing) ||
rField_is_Zn(currRing)))
||
(rField_is_Zp_a(orig_ring) && // Zp(a..) -> Zp(a..) || Zp
(rField_is_Zp(currRing, rInternalChar(orig_ring)) ||
rField_is_Zp_a(currRing, rInternalChar(orig_ring)))) )
{
par_perm_size=rPar(orig_ring);
// if ((orig_ring->minpoly != NULL) || (orig_ring->qideal != NULL))
// naSetChar(rInternalChar(orig_ring),orig_ring);
// else ntSetChar(rInternalChar(orig_ring),orig_ring);
nSetChar(currRing->cf);
}
else
{
WerrorS("coefficient fields must be equal if q-ideal !=0");
goto rCompose_err;
}
}
perm=(int *)omAlloc0((orig_ring->N+1)*sizeof(int));
if (par_perm_size!=0)
par_perm=(int *)omAlloc0(par_perm_size*sizeof(int));
int i;
#if 0
// use imap:
maFindPerm(orig_ring->names,orig_ring->N,orig_ring->parameter,orig_ring->P,
currRing->names,currRing->N,currRing->parameter, currRing->P,
perm,par_perm, currRing->ch);
#else
// use fetch
if ((rPar(orig_ring)>0) && (rPar(currRing)==0))
{
for(i=si_min(rPar(orig_ring),rVar(currRing))-1;i>=0;i--) par_perm[i]=i+1;
}
else if (par_perm_size!=0)
for(i=si_min(rPar(orig_ring),rPar(currRing))-1;i>=0;i--) par_perm[i]=-(i+1);
for(i=si_min(orig_ring->N,rVar(currRing));i>0;i--) perm[i]=i;
#endif
ideal dest_id=idInit(IDELEMS(q),1);
for(i=IDELEMS(q)-1; i>=0; i--)
{
dest_id->m[i]=p_PermPoly(q->m[i],perm,orig_ring, currRing,nMap,
par_perm,par_perm_size);
// PrintS("map:");pWrite(dest_id->m[i]);PrintLn();
pTest(dest_id->m[i]);
}
R->qideal=dest_id;
if (perm!=NULL)
omFreeSize((ADDRESS)perm,(orig_ring->N+1)*sizeof(int));
if (par_perm!=NULL)
omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
rChangeCurrRing(orig_ring);
#endif
}
else
R->qideal=idrCopyR(q,currRing,R);
}
}
else
{
WerrorS("q-ideal must be given as `ideal`");
goto rCompose_err;
}
// ---------------------------------------------------------------
#ifdef HAVE_PLURAL
if (L->nr==5)
{
if (nc_CallPlural((matrix)L->m[4].Data(),
(matrix)L->m[5].Data(),
NULL,NULL,
R,
true, // !!!
true, false,
currRing, FALSE)) goto rCompose_err;
// takes care about non-comm. quotient! i.e. calls "nc_SetupQuotient" due to last true
}
#endif
return R;
rCompose_err:
if (R->N>0)
{
int i;
if (R->names!=NULL)
{
i=R->N-1;
while (i>=0) { omfree(R->names[i]); i--; }
omFree(R->names);
}
}
omfree(R->order);
omfree(R->block0);
omfree(R->block1);
omfree(R->wvhdl);
omFree(R);
return NULL;
}
AlgExtInfo::r
ring r
Definition algext.h:37
GFInfo::GFDegree
int GFDegree
Definition coeffs.h:102
n_GF
@ n_GF
\GF{p^n < 2^16}
Definition coeffs.h:32
n_Q
@ n_Q
rational (GMP) numbers
Definition coeffs.h:30
n_Zn
@ n_Zn
only used if HAVE_RINGS is defined
Definition coeffs.h:44
n_Zp
@ n_Zp
\F{p < 2^31}
Definition coeffs.h:29
fftable
const unsigned short fftable[]
Definition ffields.cc:27
nSetChar
static FORCE_INLINE void nSetChar(const coeffs r)
initialisations after each ring change
Definition coeffs.h:446
GFInfo::GFPar_name
const char * GFPar_name
Definition coeffs.h:103
GFInfo::GFChar
int GFChar
Definition coeffs.h:101
GFInfo
Creation data needed for finite fields.
Definition coeffs.h:100
rRenameVars
static void rRenameVars(ring R)
Definition ipshell.cc:2395
rComposeC
void rComposeC(lists L, ring R)
Definition ipshell.cc:2252
rComposeOrder
static BOOLEAN rComposeOrder(const lists L, const BOOLEAN check_comp, ring R)
Definition ipshell.cc:2482
rCompose
ring rCompose(const lists L, const BOOLEAN check_comp, const long bitmask, const int isLetterplace)
Definition ipshell.cc:2782
rComposeRing
void rComposeRing(lists L, ring R)
Definition ipshell.cc:2303
rComposeVar
static BOOLEAN rComposeVar(const lists L, ring R)
Definition ipshell.cc:2437
info
#define info
Definition libparse.cc:1256
nc_CallPlural
BOOLEAN nc_CallPlural(matrix cc, matrix dd, poly cn, poly dn, ring r, bool bSetupQuotient, bool bCopyInput, bool bBeQuiet, ring curr, bool dummy_ring=false)
returns TRUE if there were errors analyze inputs, check them for consistency detects nc_type,...
Definition old.gring.cc:2692
maFindPerm
void maFindPerm(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch)
Definition maps.cc:155
nSetMap
#define nSetMap(R)
Definition numbers.h:43
p_PermPoly
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4256
pTest
#define pTest(p)
Definition polys.h:415
idrCopyR
ideal idrCopyR(ideal id, ring src_r, ring dest_r)
Definition prCopy.cc:192
IsPrime
int IsPrime(int p)
Definition prime.cc:61
rComplete
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition ring.cc:3527
sip_sring_bin
VAR omBin sip_sring_bin
Definition ring.cc:43
rEqual
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
Definition ring.cc:1752
rField_is_Zp_a
static BOOLEAN rField_is_Zp_a(const ring r)
Definition ring.h:535
rField_is_Zn
static BOOLEAN rField_is_Zn(const ring r)
Definition ring.h:518
rPar
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:605
rInternalChar
static int rInternalChar(const ring r)
Definition ring.h:695
rField_is_Q_a
static BOOLEAN rField_is_Q_a(const ring r)
Definition ring.h:545
ZnmInfo
Definition rmodulon.h:17
TransExtInfo::r
ring r
Definition transext.h:88
TransExtInfo
struct for passing initialization parameters to naInitChar
Definition transext.h:88

## rDecompose()

lists rDecompose | ( | const ring | r | ) |

Definition at line 2153 of file ipshell.cc.

{
assume( r != NULL );
const coeffs C = r->cf;
assume( C != NULL );
// sanity check: require currRing==r for rings with polynomial data
if ( (r!=currRing) && (
(nCoeff_is_algExt(C) && (C != currRing->cf))
|| (r->qideal != NULL)
#ifdef HAVE_PLURAL
|| (rIsPluralRing(r))
#endif
)
)
{
WerrorS("ring with polynomial data must be the base ring or compatible");
return NULL;
}
// 0: char/ cf - ring
// 1: list (var)
// 2: list (ord)
// 3: qideal
// possibly:
// 4: C
// 5: D
lists L=(lists)omAlloc0Bin(slists_bin);
if (rIsPluralRing(r))
L->Init(6);
else
L->Init(4);
// ----------------------------------------
// 0: char/ cf - ring
if (rField_is_numeric(r))
{
rDecomposeC(&(L->m[0]),r);
}
else if (rField_is_Ring(r))
{
rDecomposeRing(&(L->m[0]),r);
}
else if ( r->cf->extRing!=NULL )// nCoeff_is_algExt(r->cf))
{
rDecomposeCF(&(L->m[0]), r->cf->extRing, r);
}
else if(rField_is_GF(r))
{
lists Lc=(lists)omAlloc0Bin(slists_bin);
Lc->Init(4);
// char:
Lc->m[0].rtyp=INT_CMD;
Lc->m[0].data=(void*)(long)r->cf->m_nfCharQ;
// var:
lists Lv=(lists)omAlloc0Bin(slists_bin);
Lv->Init(1);
Lv->m[0].rtyp=STRING_CMD;
Lv->m[0].data=(void *)omStrDup(*rParameter(r));
Lc->m[1].rtyp=LIST_CMD;
Lc->m[1].data=(void*)Lv;
// ord:
lists Lo=(lists)omAlloc0Bin(slists_bin);
Lo->Init(1);
lists Loo=(lists)omAlloc0Bin(slists_bin);
Loo->Init(2);
Loo->m[0].rtyp=STRING_CMD;
Loo->m[0].data=(void *)omStrDup(rSimpleOrdStr(ringorder_lp));
intvec *iv=new intvec(1); (*iv)[0]=1;
Loo->m[1].rtyp=INTVEC_CMD;
Loo->m[1].data=(void *)iv;
Lo->m[0].rtyp=LIST_CMD;
Lo->m[0].data=(void*)Loo;
Lc->m[2].rtyp=LIST_CMD;
Lc->m[2].data=(void*)Lo;
// q-ideal:
Lc->m[3].rtyp=IDEAL_CMD;
Lc->m[3].data=(void *)idInit(1,1);
// ----------------------
L->m[0].rtyp=LIST_CMD;
L->m[0].data=(void*)Lc;
}
else if (rField_is_Zp(r) || rField_is_Q(r))
{
L->m[0].rtyp=INT_CMD;
L->m[0].data=(void *)(long)r->cf->ch;
}
else
{
L->m[0].rtyp=CRING_CMD;
L->m[0].data=(void *)r->cf;
r->cf->ref++;
}
// ----------------------------------------
rDecompose_23456(r,L);
return L;
}
Lc
CanonicalForm Lc(const CanonicalForm &f)
Definition canonicalform.h:307
rDecomposeC
static void rDecomposeC(leftv h, const ring R)
Definition ipshell.cc:1853
rDecomposeCF
void rDecomposeCF(leftv h, const ring r, const ring R)
Definition ipshell.cc:1729
rDecomposeRing
void rDecomposeRing(leftv h, const ring R)
Definition ipshell.cc:1915
rDecompose_23456
static void rDecompose_23456(const ring r, lists L)
Definition ipshell.cc:2013
rSimpleOrdStr
const char * rSimpleOrdStr(int ord)
Definition ring.cc:78
ringorder_lp
@ ringorder_lp
Definition ring.h:78
rParameter
static char const ** rParameter(const ring r)
(r->cf->parameter)
Definition ring.h:631
rField_is_numeric
static BOOLEAN rField_is_numeric(const ring r)
Definition ring.h:521
rField_is_GF
static BOOLEAN rField_is_GF(const ring r)
Definition ring.h:527

## rDecompose_CF()

BOOLEAN rDecompose_CF | ( | leftv | res,
|  | const coeffs | C )

Definition at line 1943 of file ipshell.cc.

{
assume( C != NULL );
// sanity check: require currRing==r for rings with polynomial data
if ( nCoeff_is_algExt(C) && (C != currRing->cf))
{
WerrorS("ring with polynomial data must be the base ring or compatible");
return TRUE;
}
if (nCoeff_is_numeric(C))
{
rDecomposeC_41(res,C);
}
else if (nCoeff_is_Ring(C))
{
rDecomposeRing_41(res,C);
}
else if ( C->extRing!=NULL )// nCoeff_is_algExt(r->cf))
{
rDecomposeCF(res, C->extRing, currRing);
}
else if(nCoeff_is_GF(C))
{
lists Lc=(lists)omAlloc0Bin(slists_bin);
Lc->Init(4);
// char:
Lc->m[0].rtyp=INT_CMD;
Lc->m[0].data=(void*)(long)C->m_nfCharQ;
// var:
lists Lv=(lists)omAlloc0Bin(slists_bin);
Lv->Init(1);
Lv->m[0].rtyp=STRING_CMD;
Lv->m[0].data=(void *)omStrDup(*n_ParameterNames(C));
Lc->m[1].rtyp=LIST_CMD;
Lc->m[1].data=(void*)Lv;
// ord:
lists Lo=(lists)omAlloc0Bin(slists_bin);
Lo->Init(1);
lists Loo=(lists)omAlloc0Bin(slists_bin);
Loo->Init(2);
Loo->m[0].rtyp=STRING_CMD;
Loo->m[0].data=(void *)omStrDup(rSimpleOrdStr(ringorder_lp));
intvec *iv=new intvec(1); (*iv)[0]=1;
Loo->m[1].rtyp=INTVEC_CMD;
Loo->m[1].data=(void *)iv;
Lo->m[0].rtyp=LIST_CMD;
Lo->m[0].data=(void*)Loo;
Lc->m[2].rtyp=LIST_CMD;
Lc->m[2].data=(void*)Lo;
// q-ideal:
Lc->m[3].rtyp=IDEAL_CMD;
Lc->m[3].data=(void *)idInit(1,1);
// ----------------------
res->rtyp=LIST_CMD;
res->data=(void*)Lc;
}
else
{
res->rtyp=INT_CMD;
res->data=(void *)(long)C->ch;
}
// ----------------------------------------
return FALSE;
}
nCoeff_is_GF
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition coeffs.h:834
nCoeff_is_numeric
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition coeffs.h:827
n_ParameterNames
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition coeffs.h:773
rDecomposeC_41
static void rDecomposeC_41(leftv h, const coeffs C)
Definition ipshell.cc:1819
rDecomposeRing_41
static void rDecomposeRing_41(leftv h, const coeffs C)
Definition ipshell.cc:1888

## rDecompose_list_cf()

lists rDecompose_list_cf | ( | const ring | r | ) |

Definition at line 2114 of file ipshell.cc.

{
assume( r != NULL );
const coeffs C = r->cf;
assume( C != NULL );
// sanity check: require currRing==r for rings with polynomial data
if ( (r!=currRing) && (
(r->qideal != NULL)
#ifdef HAVE_PLURAL
|| (rIsPluralRing(r))
#endif
)
)
{
WerrorS("ring with polynomial data must be the base ring or compatible");
return NULL;
}
// 0: char/ cf - ring
// 1: list (var)
// 2: list (ord)
// 3: qideal
// possibly:
// 4: C
// 5: D
lists L=(lists)omAlloc0Bin(slists_bin);
if (rIsPluralRing(r))
L->Init(6);
else
L->Init(4);
// ----------------------------------------
// 0: char/ cf - ring
L->m[0].rtyp=CRING_CMD;
L->m[0].data=(char*)r->cf; r->cf->ref++;
// ----------------------------------------
rDecompose_23456(r,L);
return L;
}

## rDefault()

idhdl rDefault | ( | const char * | s | ) |

Definition at line 1645 of file ipshell.cc.

{
idhdl tmp=NULL;
if (s!=NULL) tmp = enterid(s, myynest, RING_CMD, &IDROOT);
if (tmp==NULL) return NULL;
if (sLastPrinted.RingDependend())
{
sLastPrinted.CleanUp();
}
ring r = IDRING(tmp) = (ring) omAlloc0Bin(sip_sring_bin);
#ifndef TEST_ZN_AS_ZP
r->cf = nInitChar(n_Zp, (void*)32003); // r->cf->ch = 32003;
#else
mpz_t modBase;
mpz_init_set_ui(modBase, (long)32003);
ZnmInfo info;
info.base= modBase;
info.exp= 1;
r->cf=nInitChar(n_Zn,(void*) &info);
r->cf->is_field=1;
r->cf->is_domain=1;
r->cf->has_simple_Inverse=1;
#endif
r->N = 3;
/*r->P = 0; Alloc0 in idhdl::set, ipid.cc*/
/*names*/
r->names = (char **) omAlloc0(3 * sizeof(char_ptr));
r->names[0] = omStrDup("x");
r->names[1] = omStrDup("y");
r->names[2] = omStrDup("z");
/*weights: entries for 3 blocks: NULL*/
r->wvhdl = (int **)omAlloc0(3 * sizeof(int_ptr));
/*order: dp,C,0*/
r->order = (rRingOrder_t *) omAlloc(3 * sizeof(rRingOrder_t *));
r->block0 = (int *)omAlloc0(3 * sizeof(int *));
r->block1 = (int *)omAlloc0(3 * sizeof(int *));
/* ringorder dp for the first block: var 1..3 */
r->order[0] = ringorder_dp;
r->block0[0] = 1;
r->block1[0] = 3;
/* ringorder C for the second block: no vars */
r->order[1] = ringorder_C;
/* the last block: everything is 0 */
r->order[2] = (rRingOrder_t)0;
/* complete ring intializations */
rComplete(r);
rSetHdl(tmp);
return currRingHdl;
}
rRingOrder_t
rRingOrder_t
order stuff
Definition ring.h:69
ringorder_C
@ ringorder_C
Definition ring.h:74
ringorder_dp
@ ringorder_dp
Definition ring.h:79
char_ptr
char * char_ptr
Definition structs.h:49
int_ptr
int * int_ptr
Definition structs.h:50

## rFindHdl()

idhdl rFindHdl | ( | ring | r,
|  | idhdl | n )

Definition at line 1701 of file ipshell.cc.

{
if ((r==NULL)||(r->VarOffset==NULL))
return NULL;
idhdl h=rSimpleFindHdl(r,IDROOT,n);
if (h!=NULL) return h;
if (IDROOT!=basePack->idroot) h=rSimpleFindHdl(r,basePack->idroot,n);
if (h!=NULL) return h;
proclevel *p=procstack;
while(p!=NULL)
{
if ((p->cPack!=basePack)
&& (p->cPack!=currPack))
h=rSimpleFindHdl(r,p->cPack->idroot,n);
if (h!=NULL) return h;
p=p->next;
}
idhdl tmp=basePack->idroot;
while (tmp!=NULL)
{
if (IDTYP(tmp)==PACKAGE_CMD)
h=rSimpleFindHdl(r,IDPACKAGE(tmp)->idroot,n);
if (h!=NULL) return h;
tmp=IDNEXT(tmp);
}
return NULL;
}
proclevel
Definition ipid.h:56
rSimpleFindHdl
static idhdl rSimpleFindHdl(const ring r, const idhdl root, const idhdl n)
Definition ipshell.cc:6269

## rInit()

ring rInit | ( | leftv | pn,
|  | leftv | rv,
|  | leftv | ord )

Definition at line 5628 of file ipshell.cc.

{
int float_len=0;
int float_len2=0;
ring R = NULL;
//BOOLEAN ffChar=FALSE;
/* ch -------------------------------------------------------*/
// get ch of ground field
// allocated ring
R = (ring) omAlloc0Bin(sip_sring_bin);
coeffs cf = NULL;
assume( pn != NULL );
const int P = pn->listLength();
if (pn->Typ()==CRING_CMD)
{
cf=(coeffs)pn->CopyD();
leftv pnn=pn;
if(P>1) /*parameter*/
{
pnn = pnn->next;
const int pars = pnn->listLength();
assume( pars > 0 );
char ** names = (char**)omAlloc0(pars * sizeof(char_ptr));
if (rSleftvList2StringArray(pnn, names))
{
WerrorS("parameter expected");
goto rInitError;
}
TransExtInfo extParam;
extParam.r = rDefault( cf, pars, names); // Q/Zp [ p_1, ... p_pars ]
for(int i=pars-1; i>=0;i--)
{
omFree(names[i]);
}
omFree(names);
cf = nInitChar(n_transExt, &extParam);
}
assume( cf != NULL );
}
else if (pn->Typ()==INT_CMD)
{
int ch = (int)(long)pn->Data();
leftv pnn=pn;
/* parameter? -------------------------------------------------------*/
pnn = pnn->next;
if (pnn == NULL) // no params!?
{
if (ch!=0)
{
int ch2=IsPrime(ch);
if ((ch<2)||(ch!=ch2))
{
Warn("%d is invalid as characteristic of the ground field. 32003 is used.", ch);
ch=32003;
}
#ifndef TEST_ZN_AS_ZP
cf = nInitChar(n_Zp, (void*)(long)ch);
#else
mpz_t modBase;
mpz_init_set_ui(modBase, (long)ch);
ZnmInfo info;
info.base= modBase;
info.exp= 1;
cf=nInitChar(n_Zn,(void*) &info);
cf->is_field=1;
cf->is_domain=1;
cf->has_simple_Inverse=1;
#endif
}
else
cf = nInitChar(n_Q, (void*)(long)ch);
}
else
{
const int pars = pnn->listLength();
assume( pars > 0 );
// predefined finite field: (p^k, a)
if ((ch!=0) && (ch!=IsPrime(ch)) && (pars == 1))
{
GFInfo param;
param.GFChar = ch;
param.GFDegree = 1;
param.GFPar_name = pnn->name;
cf = nInitChar(n_GF, &param);
}
else // (0/p, a, b, ..., z)
{
if ((ch!=0) && (ch!=IsPrime(ch)))
{
WerrorS("too many parameters");
goto rInitError;
}
char ** names = (char**)omAlloc0(pars * sizeof(char_ptr));
if (rSleftvList2StringArray(pnn, names))
{
WerrorS("parameter expected");
goto rInitError;
}
TransExtInfo extParam;
extParam.r = rDefault( ch, pars, names); // Q/Zp [ p_1, ... p_pars ]
for(int i=pars-1; i>=0;i--)
{
omFree(names[i]);
}
omFree(names);
cf = nInitChar(n_transExt, &extParam);
}
}
//if (cf==NULL) ->Error: Invalid ground field specification
}
else if ((pn->name != NULL)
&& ((strcmp(pn->name,"real")==0) || (strcmp(pn->name,"complex")==0)))
{
leftv pnn=pn->next;
BOOLEAN complex_flag=(strcmp(pn->name,"complex")==0);
if ((pnn!=NULL) && (pnn->Typ()==INT_CMD))
{
float_len=(int)(long)pnn->Data();
float_len2=float_len;
pnn=pnn->next;
if ((pnn!=NULL) && (pnn->Typ()==INT_CMD))
{
float_len2=(int)(long)pnn->Data();
pnn=pnn->next;
}
}
if (!complex_flag)
complex_flag= (pnn!=NULL) && (pnn->name!=NULL);
if( !complex_flag && (float_len <= (short)SHORT_REAL_LENGTH))
cf=nInitChar(n_R, NULL);
else // longR or longC?
{
LongComplexInfo param;
param.float_len = si_min (float_len, 32767);
param.float_len2 = si_min (float_len2, 32767);
// set the parameter name
if (complex_flag)
{
if (param.float_len < SHORT_REAL_LENGTH)
{
param.float_len= SHORT_REAL_LENGTH;
param.float_len2= SHORT_REAL_LENGTH;
}
if ((pnn == NULL) || (pnn->name == NULL))
param.par_name=(const char*)"i"; //default to i
else
param.par_name = (const char*)pnn->name;
}
cf = nInitChar(complex_flag ? n_long_C: n_long_R, (void*)&param);
}
assume( cf != NULL );
}
else if ((pn->name != NULL) && (strcmp(pn->name, "integer") == 0))
{
// TODO: change to use coeffs_BIGINT!?
mpz_t modBase;
unsigned int modExponent = 1;
mpz_init_set_si(modBase, 0);
if (pn->next!=NULL)
{
leftv pnn=pn;
if (pnn->next->Typ()==INT_CMD)
{
pnn=pnn->next;
mpz_set_ui(modBase, (long) pnn->Data());
if ((pnn->next!=NULL) && (pnn->next->Typ()==INT_CMD))
{
pnn=pnn->next;
modExponent = (long) pnn->Data();
}
while ((pnn->next!=NULL) && (pnn->next->Typ()==INT_CMD))
{
pnn=pnn->next;
mpz_mul_ui(modBase, modBase, (int)(long) pnn->Data());
}
}
else if (pnn->next->Typ()==BIGINT_CMD)
{
number p=(number)pnn->next->CopyD();
n_MPZ(modBase,p,coeffs_BIGINT);
n_Delete(&p,coeffs_BIGINT);
}
}
else
cf=nInitChar(n_Z,NULL);
if ((mpz_cmp_ui(modBase, 1) == 0) && (mpz_sgn1(modBase) < 0))
{
WerrorS("Wrong ground ring specification (module is 1)");
goto rInitError;
}
if (modExponent < 1)
{
WerrorS("Wrong ground ring specification (exponent smaller than 1");
goto rInitError;
}
// module is 0 ---> integers ringtype = 4;
// we have an exponent
if (modExponent > 1 && cf == NULL)
{
if ((mpz_cmp_ui(modBase, 2) == 0) && (modExponent <= 8*sizeof(unsigned long)))
{
/* this branch should be active for modExponent = 2..32 resp. 2..64,
depending on the size of a long on the respective platform */
//ringtype = 1; // Use Z/2^ch
cf=nInitChar(n_Z2m,(void*)(long)modExponent);
}
else
{
if (mpz_sgn1(modBase)==0)
{
WerrorS("modulus must not be 0 or parameter not allowed");
goto rInitError;
}
//ringtype = 3;
ZnmInfo info;
info.base= modBase;
info.exp= modExponent;
cf=nInitChar(n_Znm,(void*) &info); //exponent is missing
}
}
// just a module m > 1
else if (cf == NULL)
{
if (mpz_sgn1(modBase)==0)
{
WerrorS("modulus must not be 0 or parameter not allowed");
goto rInitError;
}
//ringtype = 2;
ZnmInfo info;
info.base= modBase;
info.exp= modExponent;
cf=nInitChar(n_Zn,(void*) &info);
}
assume( cf != NULL );
mpz_clear(modBase);
}
// ring NEW = OLD, (), (); where OLD is a polynomial ring...
else if ((pn->Typ()==RING_CMD) && (P == 1))
{
ring r=(ring)pn->Data();
if (r->qideal==NULL)
{
TransExtInfo extParam;
extParam.r = r;
extParam.r->ref++;
cf = nInitChar(n_transExt, &extParam); // R(a)
}
else if (IDELEMS(r->qideal)==1)
{
AlgExtInfo extParam;
extParam.r=r;
extParam.r->ref++;
cf = nInitChar(n_algExt, &extParam); // R[a]/<minideal>
}
else
{
WerrorS("algebraic extension ring must have one minpoly");
goto rInitError;
}
}
else
{
WerrorS("Wrong or unknown ground field specification");
#if 0
// debug stuff for unknown cf descriptions:
sleftv* p = pn;
while (p != NULL)
{
Print( "pn[%p]: type: %d [%s]: %p, name: %s", (void*)p, p->Typ(), Tok2Cmdname(p->Typ()), p->Data(), (p->name == NULL? "NULL" : p->name) );
PrintLn();
p = p->next;
}
#endif
goto rInitError;
}
/*every entry in the new ring is initialized to 0*/
/* characteristic -----------------------------------------------*/
/* input: 0 ch=0 : Q parameter=NULL ffChar=FALSE float_len
* 0 1 : Q(a,...) *names FALSE
* 0 -1 : R NULL FALSE 0
* 0 -1 : R NULL FALSE prec. >6
* 0 -1 : C *names FALSE prec. 0..?
* p p : Fp NULL FALSE
* p -p : Fp(a) *names FALSE
* q q : GF(q=p^n) *names TRUE
*/
if (cf==NULL)
{
WerrorS("Invalid ground field specification");
goto rInitError;
// const int ch=32003;
// cf=nInitChar(n_Zp, (void*)(long)ch);
}
assume( R != NULL );
R->cf = cf;
/* names and number of variables-------------------------------------*/
{
int l=rv->listLength();
if (l>MAX_SHORT)
{
Werror("too many ring variables(%d), max is %d",l,MAX_SHORT);
goto rInitError;
}
R->N = l; /*rv->listLength();*/
}
R->names = (char **)omAlloc0(R->N * sizeof(char_ptr));
if (rSleftvList2StringArray(rv, R->names))
{
WerrorS("name of ring variable expected");
goto rInitError;
}
/* check names and parameters for conflicts ------------------------- */
rRenameVars(R); // conflicting variables will be renamed
/* ordering -------------------------------------------------------------*/
if (rSleftvOrdering2Ordering(ord, R))
goto rInitError;
// Complete the initialization
if (rComplete(R,1))
goto rInitError;
/*#ifdef HAVE_RINGS
// currently, coefficients which are ring elements require a global ordering:
if (rField_is_Ring(R) && (R->OrdSgn==-1))
{
WerrorS("global ordering required for these coefficients");
goto rInitError;
}
#endif*/
rTest(R);
// try to enter the ring into the name list
// need to clean up sleftv here, before this ring can be set to
// new currRing or currRing can be killed beacuse new ring has
// same name
pn->CleanUp();
rv->CleanUp();
ord->CleanUp();
//if ((tmp = enterid(s, myynest, RING_CMD, &IDROOT))==NULL)
// goto rInitError;
//memcpy(IDRING(tmp),R,sizeof(*R));
// set current ring
//omFreeBin(R, ip_sring_bin);
//return tmp;
return R;
// error case:
rInitError:
if ((R != NULL)&&(R->cf!=NULL)) rDelete(R);
pn->CleanUp();
rv->CleanUp();
ord->CleanUp();
return NULL;
}
n_R
@ n_R
single prescision (6,6) real numbers
Definition coeffs.h:31
n_Znm
@ n_Znm
only used if HAVE_RINGS is defined
Definition coeffs.h:45
n_long_R
@ n_long_R
real floating point (GMP) numbers
Definition coeffs.h:33
n_Z2m
@ n_Z2m
only used if HAVE_RINGS is defined
Definition coeffs.h:46
n_Z
@ n_Z
only used if HAVE_RINGS is defined
Definition coeffs.h:43
n_long_C
@ n_long_C
complex floating point (GMP) numbers
Definition coeffs.h:41
LongComplexInfo::float_len2
short float_len2
additional char-flags, rInit
Definition coeffs.h:109
n_MPZ
static FORCE_INLINE void n_MPZ(mpz_t result, number &n, const coeffs r)
conversion of n to a GMP integer; 0 if not possible
Definition coeffs.h:554
LongComplexInfo::par_name
const char * par_name
parameter name
Definition coeffs.h:110
LongComplexInfo::float_len
short float_len
additional char-flags, rInit
Definition coeffs.h:108
LongComplexInfo
Definition coeffs.h:107
rDefault
idhdl rDefault(const char *s)
Definition ipshell.cc:1645
MAX_SHORT
const short MAX_SHORT
Definition ipshell.cc:5616
rSleftvOrdering2Ordering
BOOLEAN rSleftvOrdering2Ordering(sleftv *ord, ring R)
Definition ipshell.cc:5308
rSleftvList2StringArray
static BOOLEAN rSleftvList2StringArray(leftv sl, char **p)
Definition ipshell.cc:5580
SHORT_REAL_LENGTH
#define SHORT_REAL_LENGTH
Definition numbers.h:57
rTest
#define rTest(r)
Definition ring.h:794
mpz_sgn1
#define mpz_sgn1(A)
Definition si_gmp.h:18

## rKill() [1/2]

void rKill | ( | idhdl | h | ) |

Definition at line 6226 of file ipshell.cc.

{
ring r = IDRING(h);
int ref=0;
if (r!=NULL)
{
// avoid, that sLastPrinted is the last reference to the base ring:
// clean up before killing the last "named" refrence:
if ((sLastPrinted.rtyp==RING_CMD)
&& (sLastPrinted.data==(void*)r))
{
sLastPrinted.CleanUp(r);
}
ref=r->ref;
if ((ref<=0)&&(r==currRing))
{
// cleanup DENOMINATOR_LIST
if (DENOMINATOR_LIST!=NULL)
{
denominator_list dd=DENOMINATOR_LIST;
if (TEST_V_ALLWARN)
Warn("deleting denom_list for ring change from %s",IDID(h));
do
{
n_Delete(&(dd->n),currRing->cf);
dd=dd->next;
omFreeBinAddr(DENOMINATOR_LIST);
DENOMINATOR_LIST=dd;
} while(DENOMINATOR_LIST!=NULL);
}
}
rKill(r);
}
if (h==currRingHdl)
{
if (ref<=0) { currRing=NULL; currRingHdl=NULL;}
else
{
currRingHdl=rFindHdl(r,currRingHdl);
}
}
}
rKill
void rKill(ring r)
Definition ipshell.cc:6181
DENOMINATOR_LIST
VAR denominator_list DENOMINATOR_LIST
Definition kutil.cc:79
denominator_list
denominator_list_s * denominator_list
Definition kutil.h:64
denominator_list_s::n
number n
Definition kutil.h:66
denominator_list_s::next
denominator_list next
Definition kutil.h:66

## rKill() [2/2]

void rKill | ( | ring | r | ) |

Definition at line 6181 of file ipshell.cc.

{
if ((r->ref<=0)&&(r->order!=NULL))
{
#ifdef RDEBUG
if (traceit &TRACE_SHOW_RINGS) Print("kill ring %lx\n",(long)r);
#endif
int j;
for (j=0;j<myynest;j++)
{
if (iiLocalRing[j]==r)
{
if (j==0) WarnS("killing the basering for level 0");
iiLocalRing[j]=NULL;
}
}
// any variables depending on r ?
while (r->idroot!=NULL)
{
r->idroot->lev=myynest; // avoid warning about kill global objects
killhdl2(r->idroot,&(r->idroot),r);
}
if (r==currRing)
{
// all dependend stuff is done, clean global vars:
if (sLastPrinted.RingDependend())
{
sLastPrinted.CleanUp();
}
//if ((myynest>0) && (iiRETURNEXPR.RingDependend()))
//{
// WerrorS("return value depends on local ring variable (export missing ?)");
// iiRETURNEXPR.CleanUp();
//}
currRing=NULL;
currRingHdl=NULL;
}
/* nKillChar(r); will be called from inside of rDelete */
rDelete(r);
return;
}
rDecRefCnt(r);
}
rDecRefCnt
static void rDecRefCnt(ring r)
Definition ring.h:850

## rSetHdl()

void rSetHdl | ( | idhdl | h | ) |

Definition at line 5129 of file ipshell.cc.

{
ring rg = NULL;
if (h!=NULL)
{
// Print(" new ring:%s (l:%d)\n",IDID(h),IDLEV(h));
rg = IDRING(h);
if (rg==NULL) return; //id <>NULL, ring==NULL
omCheckAddrSize((ADDRESS)h,sizeof(idrec));
if (IDID(h)) // OB: ????
omCheckAddr((ADDRESS)IDID(h));
rTest(rg);
}
else return;
// clean up history
if (currRing!=NULL)
{
if(sLastPrinted.RingDependend())
{
sLastPrinted.CleanUp();
}
if (rg!=currRing)/*&&(currRing!=NULL)*/
{
if (rg->cf!=currRing->cf)
{
denominator_list dd=DENOMINATOR_LIST;
if (DENOMINATOR_LIST!=NULL)
{
if (TEST_V_ALLWARN)
Warn("deleting denom_list for ring change to %s",IDID(h));
do
{
n_Delete(&(dd->n),currRing->cf);
dd=dd->next;
omFreeBinAddr(DENOMINATOR_LIST);
DENOMINATOR_LIST=dd;
} while(DENOMINATOR_LIST!=NULL);
}
}
}
}
// test for valid "currRing":
if ((rg!=NULL) && (rg->idroot==NULL))
{
ring old=rg;
rg=rAssure_HasComp(rg);
if (old!=rg)
{
rKill(old);
IDRING(h)=rg;
}
}
/*------------ change the global ring -----------------------*/
rChangeCurrRing(rg);
currRingHdl = h;
}
idrec
Definition idrec.h:35
omCheckAddr
#define omCheckAddr(addr)
Definition omAllocDecl.h:328
omCheckAddrSize
#define omCheckAddrSize(addr, size)
Definition omAllocDecl.h:327
rAssure_HasComp
ring rAssure_HasComp(const ring r)
Definition ring.cc:4717

## scIndIndset()

lists scIndIndset | ( | ideal | S,
|  | BOOLEAN | all,
|  | ideal | Q )

Definition at line 1111 of file ipshell.cc.

{
int i;
indset save;
lists res=(lists)omAlloc0Bin(slists_bin);
hexist = hInit(S, Q, &hNexist);
if (hNexist == 0)
{
intvec *iv=new intvec(rVar(currRing));
for(i=0; i<rVar(currRing); i++) (*iv)[i]=1;
res->Init(1);
res->m[0].rtyp=INTVEC_CMD;
res->m[0].data=(intvec*)iv;
return res;
}
save = ISet = (indset)omAlloc0Bin(indlist_bin);
hMu = 0;
hwork = (scfmon)omAlloc(hNexist * sizeof(scmon));
hvar = (varset)omAlloc((rVar(currRing) + 1) * sizeof(int));
hpure = (scmon)omAlloc0((1 + (rVar(currRing) * rVar(currRing))) * sizeof(long));
hrad = hexist;
hNrad = hNexist;
radmem = hCreate(rVar(currRing) - 1);
hCo = rVar(currRing) + 1;
hNvar = rVar(currRing);
hRadical(hrad, &hNrad, hNvar);
hSupp(hrad, hNrad, hvar, &hNvar);
if (hNvar)
{
hCo = hNvar;
hPure(hrad, 0, &hNrad, hvar, hNvar, hpure, &hNpure);
hLexR(hrad, hNrad, hvar, hNvar);
hDimSolve(hpure, hNpure, hrad, hNrad, hvar, hNvar);
}
if (hCo && (hCo < rVar(currRing)))
{
hIndMult(hpure, hNpure, hrad, hNrad, hvar, hNvar);
}
if (hMu!=0)
{
ISet = save;
hMu2 = 0;
if (all && (hCo+1 < rVar(currRing)))
{
JSet = (indset)omAlloc0Bin(indlist_bin);
hIndAllMult(hpure, hNpure, hrad, hNrad, hvar, hNvar);
i=hMu+hMu2;
res->Init(i);
if (hMu2 == 0)
{
omFreeBin((ADDRESS)JSet, indlist_bin);
}
}
else
{
res->Init(hMu);
}
for (i=0;i<hMu;i++)
{
res->m[i].data = (void *)save->set;
res->m[i].rtyp = INTVEC_CMD;
ISet = save;
save = save->nx;
omFreeBin((ADDRESS)ISet, indlist_bin);
}
omFreeBin((ADDRESS)save, indlist_bin);
if (hMu2 != 0)
{
save = JSet;
for (i=hMu;i<hMu+hMu2;i++)
{
res->m[i].data = (void *)save->set;
res->m[i].rtyp = INTVEC_CMD;
JSet = save;
save = save->nx;
omFreeBin((ADDRESS)JSet, indlist_bin);
}
omFreeBin((ADDRESS)save, indlist_bin);
}
}
else
{
res->Init(0);
omFreeBin((ADDRESS)ISet, indlist_bin);
}
hKill(radmem, rVar(currRing) - 1);
omFreeSize((ADDRESS)hpure, (1 + (rVar(currRing) * rVar(currRing))) * sizeof(long));
omFreeSize((ADDRESS)hvar, (rVar(currRing) + 1) * sizeof(int));
omFreeSize((ADDRESS)hwork, hNexist * sizeof(scmon));
hDelete(hexist, hNexist);
return res;
}
hIndMult
void hIndMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition hdegree.cc:382
indlist_bin
VAR omBin indlist_bin
Definition hdegree.cc:29
hMu2
VAR int hMu2
Definition hdegree.cc:27
hCo
VAR int hCo
Definition hdegree.cc:27
ISet
VAR indset ISet
Definition hdegree.cc:351
hMu
VAR long hMu
Definition hdegree.cc:28
JSet
VAR indset JSet
Definition hdegree.cc:351
hDimSolve
void hDimSolve(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition hdegree.cc:35
hIndAllMult
void hIndAllMult(scmon pure, int Npure, scfmon rad, int Nrad, varset var, int Nvar)
Definition hdegree.cc:562
hCreate
monf hCreate(int Nvar)
Definition hutil.cc:996
hvar
VAR varset hvar
Definition hutil.cc:18
hKill
void hKill(monf xmem, int Nvar)
Definition hutil.cc:1010
hNexist
VAR int hNexist
Definition hutil.cc:19
hDelete
void hDelete(scfmon ev, int ev_length)
Definition hutil.cc:140
hPure
void hPure(scfmon stc, int a, int *Nstc, varset var, int Nvar, scmon pure, int *Npure)
Definition hutil.cc:621
hwork
VAR scfmon hwork
Definition hutil.cc:16
hSupp
void hSupp(scfmon stc, int Nstc, varset var, int *Nvar)
Definition hutil.cc:174
hLexR
void hLexR(scfmon rad, int Nrad, varset var, int Nvar)
Definition hutil.cc:565
hpure
VAR scmon hpure
Definition hutil.cc:17
hrad
VAR scfmon hrad
Definition hutil.cc:16
radmem
VAR monf radmem
Definition hutil.cc:21
hNpure
VAR int hNpure
Definition hutil.cc:19
hNrad
VAR int hNrad
Definition hutil.cc:19
hInit
scfmon hInit(ideal S, ideal Q, int *Nexist)
Definition hutil.cc:31
hexist
VAR scfmon hexist
Definition hutil.cc:16
hRadical
void hRadical(scfmon rad, int *Nrad, int Nvar)
Definition hutil.cc:411
hNvar
VAR int hNvar
Definition hutil.cc:19
scfmon
scmon * scfmon
Definition hutil.h:15
indset
indlist * indset
Definition hutil.h:28
varset
int * varset
Definition hutil.h:16
scmon
int * scmon
Definition hutil.h:14
Q
#define Q
Definition sirandom.c:26

## semicProc()

BOOLEAN semicProc | ( | leftv | res,
|  | leftv | u,
|  | leftv | v )

Definition at line 4554 of file ipshell.cc.

{
sleftv tmp;
tmp.Init();
tmp.rtyp=INT_CMD;
/* tmp.data = (void *)0; -- done by Init */
return semicProc3(res,u,v,&tmp);
}

## semicProc3()

BOOLEAN semicProc3 | ( | leftv | res,
|  | leftv | u,
|  | leftv | v,
|  | leftv | w )

Definition at line 4514 of file ipshell.cc.

{
semicState state;
BOOLEAN qh=(((int)(long)w->Data())==1);
// -----------------
// check arguments
// -----------------
lists l1 = (lists)u->Data( );
lists l2 = (lists)v->Data( );
if( (state=list_is_spectrum( l1 ))!=semicOK )
{
WerrorS( "first argument is not a spectrum" );
list_error( state );
}
else if( (state=list_is_spectrum( l2 ))!=semicOK )
{
WerrorS( "second argument is not a spectrum" );
list_error( state );
}
else
{
spectrum s1= spectrumFromList( l1 );
spectrum s2= spectrumFromList( l2 );
res->rtyp = INT_CMD;
if (qh)
res->data = (void*)(long)(s1.mult_spectrumh( s2 ));
else
res->data = (void*)(long)(s1.mult_spectrum( s2 ));
}
// -----------------
// check status
// -----------------
return (state!=semicOK);
}
spectrum
Definition semic.h:64
spectrum::mult_spectrum
int mult_spectrum(spectrum &)
Definition semic.cc:396
spectrum::mult_spectrumh
int mult_spectrumh(spectrum &)
Definition semic.cc:425
semicState
semicState
Definition ipshell.cc:3437
semicOK
@ semicOK
Definition ipshell.cc:3438
list_error
void list_error(semicState state)
Definition ipshell.cc:3470
spectrumFromList
spectrum spectrumFromList(lists l)
Definition ipshell.cc:3386
list_is_spectrum
semicState list_is_spectrum(lists l)
Definition ipshell.cc:4256

## setOption()

BOOLEAN setOption | ( | leftv | res,
|  | leftv | v )

Definition at line 570 of file misc_ip.cc.

{
const char *n;
do
{
if (v->Typ()==STRING_CMD)
{
n=(const char *)v->CopyD(STRING_CMD);
}
else
{
if (v->name==NULL)
return TRUE;
if (v->rtyp==0)
{
n=v->name;
v->name=NULL;
}
else
{
n=omStrDup(v->name);
}
}
int i;
if(strcmp(n,"get")==0)
{
intvec *w=new intvec(2);
(*w)[0]=si_opt_1;
(*w)[1]=si_opt_2;
res->rtyp=INTVEC_CMD;
res->data=(void *)w;
goto okay;
}
if(strcmp(n,"set")==0)
{
if((v->next!=NULL)
&&(v->next->Typ()==INTVEC_CMD))
{
v=v->next;
intvec *w=(intvec*)v->Data();
si_opt_1=(*w)[0];
si_opt_2=(*w)[1];
#if 0
if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
&& rField_has_simple_inverse()
&& !rField_is_Ring(currRing)
) {
si_opt_1 &=~Sy_bit(OPT_INTSTRATEGY);
}
#endif
goto okay;
}
}
if(strcmp(n,"none")==0)
{
si_opt_1=0;
si_opt_2=0;
goto okay;
}
for (i=0; (i==0) || (optionStruct[i-1].setval!=0); i++)
{
if (strcmp(n,optionStruct[i].name)==0)
{
if (optionStruct[i].setval & validOpts)
{
si_opt_1 |= optionStruct[i].setval;
// optOldStd disables redthrough
if (optionStruct[i].setval == Sy_bit(OPT_OLDSTD))
si_opt_1 &= ~Sy_bit(OPT_REDTHROUGH);
}
else
WarnS("cannot set option");
#if 0
if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
&& rField_has_simple_inverse()
&& !rField_is_Ring(currRing)
) {
test &=~Sy_bit(OPT_INTSTRATEGY);
}
#endif
goto okay;
}
else if ((strncmp(n,"no",2)==0)
&& (strcmp(n+2,optionStruct[i].name)==0))
{
if (optionStruct[i].setval & validOpts)
{
si_opt_1 &= optionStruct[i].resetval;
}
else
WarnS("cannot clear option");
goto okay;
}
}
for (i=0; (i==0) || (verboseStruct[i-1].setval!=0); i++)
{
if (strcmp(n,verboseStruct[i].name)==0)
{
si_opt_2 |= verboseStruct[i].setval;
#ifdef YYDEBUG
#if YYDEBUG
/*debugging the bison grammar --> grammar.cc*/
EXTERN_VAR int yydebug;
if (BVERBOSE(V_YACC)) yydebug=1;
else yydebug=0;
#endif
#endif
goto okay;
}
else if ((strncmp(n,"no",2)==0)
&& (strcmp(n+2,verboseStruct[i].name)==0))
{
si_opt_2 &= verboseStruct[i].resetval;
#ifdef YYDEBUG
#if YYDEBUG
/*debugging the bison grammar --> grammar.cc*/
EXTERN_VAR int yydebug;
if (BVERBOSE(V_YACC)) yydebug=1;
else yydebug=0;
#endif
#endif
goto okay;
}
}
Werror("unknown option `%s`",n);
okay:
if (currRing != NULL)
currRing->options = si_opt_1 & TEST_RINGDEP_OPTS;
omFreeBinAddr((ADDRESS)n);
v=v->next;
} while (v!=NULL);
// set global variable to show memory usage
if (BVERBOSE(V_SHOW_MEM)) om_sing_opt_show_mem = 1;
else om_sing_opt_show_mem = 0;
return FALSE;
}
test
CanonicalForm test
Definition cfModGcd.cc:4104
yydebug
int yydebug
Definition grammar.cc:1843
validOpts
VAR BITSET validOpts
Definition kstd1.cc:60
om_sing_opt_show_mem
int om_sing_opt_show_mem
OPT_INTSTRATEGY
#define OPT_INTSTRATEGY
Definition options.h:93
TEST_OPT_INTSTRATEGY
#define TEST_OPT_INTSTRATEGY
Definition options.h:112
V_SHOW_MEM
#define V_SHOW_MEM
Definition options.h:43
V_YACC
#define V_YACC
Definition options.h:44
OPT_REDTHROUGH
#define OPT_REDTHROUGH
Definition options.h:83
TEST_RINGDEP_OPTS
#define TEST_RINGDEP_OPTS
Definition options.h:101
OPT_OLDSTD
#define OPT_OLDSTD
Definition options.h:87
rField_has_simple_inverse
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition ring.h:554

## showOption()

char * showOption | ( |  | ) |

Definition at line 711 of file misc_ip.cc.

{
int i;
BITSET tmp;
StringSetS("//options:");
if ((si_opt_1!=0)||(si_opt_2!=0))
{
tmp=si_opt_1;
if(tmp)
{
for (i=0; optionStruct[i].setval!=0; i++)
{
if (optionStruct[i].setval & tmp)
{
StringAppend(" %s",optionStruct[i].name);
tmp &=optionStruct[i].resetval;
}
}
for (i=0; i<32; i++)
{
if (tmp & Sy_bit(i)) StringAppend(" %d",i);
}
}
tmp=si_opt_2;
if (tmp)
{
for (i=0; verboseStruct[i].setval!=0; i++)
{
if (verboseStruct[i].setval & tmp)
{
StringAppend(" %s",verboseStruct[i].name);
tmp &=verboseStruct[i].resetval;
}
}
for (i=1; i<32; i++)
{
if (tmp & Sy_bit(i)) StringAppend(" %d",i+32);
}
}
return StringEndS();
}
StringAppendS(" none");
return StringEndS();
}
StringAppend
#define StringAppend
Definition emacs.cc:79
StringAppendS
void StringAppendS(const char *st)
Definition reporter.cc:107

## singular_example()

void singular_example | ( | char * | str | ) |

Definition at line 431 of file misc_ip.cc.

{
assume(str!=NULL);
char *s=str;
while (*s==' ') s++;
char *ss=s;
while (*ss!='\0') ss++;
while (*ss<=' ')
{
*ss='\0';
ss--;
}
idhdl h=IDROOT->get_level(s,0);
if ((h!=NULL) && (IDTYP(h)==PROC_CMD))
{
char *lib=iiGetLibName(IDPROC(h));
if((lib!=NULL)&&(*lib!='\0'))
{
Print("// proc %s from lib %s\n",s,lib);
s=iiGetLibProcBuffer(IDPROC(h), 2);
if (s!=NULL)
{
if (strlen(s)>5)
{
iiEStart(s,IDPROC(h));
omFree((ADDRESS)s);
return;
}
else omFree((ADDRESS)s);
}
}
}
else
{
char sing_file[MAXPATHLEN];
FILE *fd=NULL;
char *res_m=feResource('m', 0);
if (res_m!=NULL)
{
snprintf(sing_file,MAXPATHLEN, "%s/%s.sing", res_m, s);
fd = feFopen(sing_file, "r");
}
if (fd != NULL)
{
int old_echo = si_echo;
int length, got;
char* s;
fseek(fd, 0, SEEK_END);
length = ftell(fd);
fseek(fd, 0, SEEK_SET);
s = (char*) omAlloc((length+20)*sizeof(char));
got = fread(s, sizeof(char), length, fd);
fclose(fd);
if (got != length)
{
Werror("Error while reading file %s", sing_file);
}
else
{
s[length] = '\0';
strcat(s, "\n;return();\n\n");
si_echo = 2;
iiEStart(s, NULL);
si_echo = old_echo;
}
omFree(s);
}
else
{
Werror("no example for %s", str);
}
}
}
iiEStart
BOOLEAN iiEStart(char *example, procinfo *pi)
Definition iplib.cc:763
iiGetLibName
static char * iiGetLibName(const procinfov pi)
find the library of an proc
Definition ipshell.h:66
SEEK_SET
#define SEEK_SET
Definition mod2.h:115
SEEK_END
#define SEEK_END
Definition mod2.h:111
LibThread::str
char * str(leftv arg)
Definition shared.cc:699
fd
int status int fd
Definition si_signals.h:69

## singular_system()

leftv singular_system | ( | sleftv | h | ) |

## siSetCpus()

int siSetCpus | ( | int | cpu | ) |

Definition at line 6665 of file ipshell.cc.

{
int old=(int)(long)feOptValue(FE_OPT_CPUS);
feSetOptValue(FE_OPT_CPUS,cpu);
return old;
}

## spaddProc()

BOOLEAN spaddProc | ( | leftv | result,
|  | leftv | first,
|  | leftv | second )

Definition at line 4431 of file ipshell.cc.

{
semicState state;
// -----------------
// check arguments
// -----------------
lists l1 = (lists)first->Data( );
lists l2 = (lists)second->Data( );
if( (state=list_is_spectrum( l1 )) != semicOK )
{
WerrorS( "first argument is not a spectrum:" );
list_error( state );
}
else if( (state=list_is_spectrum( l2 )) != semicOK )
{
WerrorS( "second argument is not a spectrum:" );
list_error( state );
}
else
{
spectrum s1= spectrumFromList ( l1 );
spectrum s2= spectrumFromList ( l2 );
spectrum sum( s1+s2 );
result->rtyp = LIST_CMD;
result->data = (char*)(getList(sum));
}
return (state!=semicOK);
}
getList
lists getList(spectrum &spec)
Definition ipshell.cc:3398

## spectrumfProc()

BOOLEAN spectrumfProc | ( | leftv | result,
|  | leftv | first )

Definition at line 4187 of file ipshell.cc.

{
spectrumState state = spectrumOK;
// -------------------
// check consistency
// -------------------
// check for a local polynomial ring
if( currRing->OrdSgn != -1 )
// ?? HS: the test above is also true for k[x][[y]], k[[x]][y]
// or should we use:
//if( !ringIsLocal( ) )
{
WerrorS( "only works for local orderings" );
state = spectrumWrongRing;
}
else if( currRing->qideal != NULL )
{
WerrorS( "does not work in quotient rings" );
state = spectrumWrongRing;
}
else
{
lists L = (lists)NULL;
int flag = 2; // symmetric optimization
state = spectrumCompute( (poly)first->Data( ),&L,flag );
if( state==spectrumOK )
{
result->rtyp = LIST_CMD;
result->data = (char*)L;
}
else
{
spectrumPrintError(state);
}
}
return (state!=spectrumOK);
}
spectrumState
spectrumState
Definition ipshell.cc:3553
spectrumWrongRing
@ spectrumWrongRing
Definition ipshell.cc:3560
spectrumOK
@ spectrumOK
Definition ipshell.cc:3554
spectrumCompute
spectrumState spectrumCompute(poly h, lists *L, int fast)
Definition ipshell.cc:3812
spectrumPrintError
void spectrumPrintError(spectrumState state)
Definition ipshell.cc:4105

## spectrumProc()

BOOLEAN spectrumProc | ( | leftv | result,
|  | leftv | first )

Definition at line 4136 of file ipshell.cc.

{
spectrumState state = spectrumOK;
// -------------------
// check consistency
// -------------------
// check for a local ring
if( !ringIsLocal(currRing ) )
{
WerrorS( "only works for local orderings" );
state = spectrumWrongRing;
}
// no quotient rings are allowed
else if( currRing->qideal != NULL )
{
WerrorS( "does not work in quotient rings" );
state = spectrumWrongRing;
}
else
{
lists L = (lists)NULL;
int flag = 1; // weight corner optimization is safe
state = spectrumCompute( (poly)first->Data( ),&L,flag );
if( state==spectrumOK )
{
result->rtyp = LIST_CMD;
result->data = (char*)L;
}
else
{
spectrumPrintError(state);
}
}
return (state!=spectrumOK);
}
ringIsLocal
BOOLEAN ringIsLocal(const ring r)
Definition spectrum.cc:461

## spmulProc()

BOOLEAN spmulProc | ( | leftv | result,
|  | leftv | first,
|  | leftv | second )

Definition at line 4473 of file ipshell.cc.

{
semicState state;
// -----------------
// check arguments
// -----------------
lists l = (lists)first->Data( );
int k = (int)(long)second->Data( );
if( (state=list_is_spectrum( l ))!=semicOK )
{
WerrorS( "first argument is not a spectrum" );
list_error( state );
}
else if( k < 0 )
{
WerrorS( "second argument should be positive" );
state = semicMulNegative;
}
else
{
spectrum s= spectrumFromList( l );
spectrum product( k*s );
result->rtyp = LIST_CMD;
result->data = (char*)getList(product);
}
return (state!=semicOK);
}
semicMulNegative
@ semicMulNegative
Definition ipshell.cc:3439

## syBetti1()

BOOLEAN syBetti1 | ( | leftv | res,
|  | leftv | u )

Definition at line 3166 of file ipshell.cc.

{
sleftv tmp;
tmp.Init();
tmp.rtyp=INT_CMD;
tmp.data=(void *)1;
return syBetti2(res,u,&tmp);
}
syBetti2
BOOLEAN syBetti2(leftv res, leftv u, leftv w)
Definition ipshell.cc:3142

## syBetti2()

BOOLEAN syBetti2 | ( | leftv | res,
|  | leftv | u,
|  | leftv | w )

Definition at line 3142 of file ipshell.cc.

{
syStrategy syzstr=(syStrategy)u->Data();
BOOLEAN minim=(int)(long)w->Data();
int row_shift=0;
int add_row_shift=0;
intvec *weights=NULL;
intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
if (ww!=NULL)
{
weights=ivCopy(ww);
add_row_shift = ww->min_in();
(*weights) -= add_row_shift;
}
res->data=(void *)syBettiOfComputation(syzstr,minim,&row_shift,weights);
if (ww!=NULL) delete weights;
//row_shift += add_row_shift;
//Print("row_shift=%d, add_row_shift=%d\n",row_shift,add_row_shift);
atSet(res,omStrDup("rowShift"),(void*)(long)add_row_shift,INT_CMD);
return FALSE;
}
syBettiOfComputation
intvec * syBettiOfComputation(syStrategy syzstr, BOOLEAN minim=TRUE, int *row_shift=NULL, intvec *weights=NULL)
Definition syz1.cc:1756

## syConvList()

syStrategy syConvList | ( | lists | li | ) |

Definition at line 3250 of file ipshell.cc.

{
int typ0;
syStrategy result=(syStrategy)omAlloc0(sizeof(ssyStrategy));
resolvente fr = liFindRes(li,&(result->length),&typ0,&(result->weights));
if (fr != NULL)
{
result->fullres = (resolvente)omAlloc0((result->length+1)*sizeof(ideal));
for (int i=result->length-1;i>=0;i--)
{
if (fr[i]!=NULL)
result->fullres[i] = idCopy(fr[i]);
}
result->list_length=result->length;
omFreeSize((ADDRESS)fr,(result->length)*sizeof(ideal));
}
else
{
omFreeSize(result, sizeof(ssyStrategy));
result = NULL;
}
return result;
}
ssyStrategy
Definition syz.h:37

## syConvRes()

lists syConvRes | ( | syStrategy | syzstr,
|  | BOOLEAN | toDel = FALSE,
|  | int | add_row_shift = 0 )

Definition at line 3178 of file ipshell.cc.

{
resolvente fullres = syzstr->fullres;
resolvente minres = syzstr->minres;
const int length = syzstr->length;
if ((fullres==NULL) && (minres==NULL))
{
if (syzstr->hilb_coeffs==NULL)
{ // La Scala
fullres = syReorder(syzstr->res, length, syzstr);
}
else
{ // HRES
minres = syReorder(syzstr->orderedRes, length, syzstr);
syKillEmptyEntres(minres, length);
}
}
resolvente tr;
int typ0=IDEAL_CMD;
if (minres!=NULL)
tr = minres;
else
tr = fullres;
resolvente trueres=NULL;
intvec ** w=NULL;
if (length>0)
{
trueres = (resolvente)omAlloc0((length)*sizeof(ideal));
for (int i=length-1;i>=0;i--)
{
if (tr[i]!=NULL)
{
trueres[i] = idCopy(tr[i]);
}
}
if ( id_RankFreeModule(trueres[0], currRing) > 0)
typ0 = MODUL_CMD;
if (syzstr->weights!=NULL)
{
w = (intvec**)omAlloc0(length*sizeof(intvec*));
for (int i=length-1;i>=0;i--)
{
if (syzstr->weights[i]!=NULL) w[i] = ivCopy(syzstr->weights[i]);
}
}
}
lists li = liMakeResolv(trueres, length, syzstr->list_length,typ0,
w, add_row_shift);
if (toDel)
syKillComputation(syzstr);
else
{
if( fullres != NULL && syzstr->fullres == NULL )
syzstr->fullres = fullres;
if( minres != NULL && syzstr->minres == NULL )
syzstr->minres = minres;
}
return li;
}
id_RankFreeModule
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
Definition simpleideals.cc:992
ssyStrategy::hilb_coeffs
intvec ** hilb_coeffs
Definition syz.h:46
ssyStrategy::minres
resolvente minres
Definition syz.h:58
syKillComputation
void syKillComputation(syStrategy syzstr, ring r=currRing)
Definition syz1.cc:1495
syReorder
resolvente syReorder(resolvente res, int length, syStrategy syzstr, BOOLEAN toCopy=TRUE, resolvente totake=NULL)
Definition syz1.cc:1641
syKillEmptyEntres
void syKillEmptyEntres(resolvente res, int length)
Definition syz1.cc:2199
ssyStrategy::list_length
short list_length
Definition syz.h:62
ssyStrategy::res
resolvente res
Definition syz.h:47
ssyStrategy::fullres
resolvente fullres
Definition syz.h:57
ssyStrategy::weights
intvec ** weights
Definition syz.h:45
ssyStrategy::orderedRes
resolvente orderedRes
Definition syz.h:48
ssyStrategy::length
int length
Definition syz.h:60

## test_cmd()

void test_cmd | ( | int | i | ) |

Definition at line 513 of file ipshell.cc.

{
int ii;
if (i<0)
{
ii= -i;
if (ii < 32)
{
si_opt_1 &= ~Sy_bit(ii);
}
else if (ii < 64)
{
si_opt_2 &= ~Sy_bit(ii-32);
}
else
WerrorS("out of bounds\n");
}
else if (i<32)
{
ii=i;
if (Sy_bit(ii) & kOptions)
{
WarnS("Gerhard, use the option command");
si_opt_1 |= Sy_bit(ii);
}
else if (Sy_bit(ii) & validOpts)
si_opt_1 |= Sy_bit(ii);
}
else if (i<64)
{
ii=i-32;
si_opt_2 |= Sy_bit(ii);
}
else
WerrorS("out of bounds\n");
}
kOptions
VAR BITSET kOptions
Definition kstd1.cc:45

## Tok2Cmdname()

const char * Tok2Cmdname | ( | int | i | ) |

Definition at line 137 of file gentable.cc.

{
if (tok < 0)
{
return cmds[0].name;
}
if (tok==COMMAND) return "command";
if (tok==ANY_TYPE) return "any_type";
if (tok==NONE) return "nothing";
//if (tok==IFBREAK) return "if_break";
//if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
//if (tok==ORDER_VECTOR) return "ordering";
//if (tok==REF_VAR) return "ref";
//if (tok==OBJECT) return "object";
//if (tok==PRINT_EXPR) return "print_expr";
if (tok==IDHDL) return "identifier";
// we do not blackbox objects during table generation:
//if (tok>MAX_TOK) return getBlackboxName(tok);
int i = 0;
while (cmds[i].tokval!=0)
{
if ((cmds[i].tokval == tok)&&(cmds[i].alias==0))
{
return cmds[i].name;
}
i++;
}
i=0;// try again for old/alias names:
while (cmds[i].tokval!=0)
{
if (cmds[i].tokval == tok)
{
return cmds[i].name;
}
i++;
}
#if 0
char *s=(char*)malloc(10);
snprintf(s,10,"(%d)",tok);
return s;
#else
return cmds[0].name;
#endif
}
malloc
#define malloc
Definition omAllocFunc.c:12
cmds
VAR cmdnames cmds[]
Definition table.h:1027

## type_cmd()

void type_cmd | ( | leftv | v | ) |

Definition at line 255 of file ipshell.cc.

{
BOOLEAN oldShortOut = FALSE;
if (currRing != NULL)
{
oldShortOut = currRing->ShortOut;
currRing->ShortOut = 1;
}
int t=v->Typ();
Print("// %s %s ",v->Name(),Tok2Cmdname(t));
switch (t)
{
case MAP_CMD:Print(" from %s\n",((map)(v->Data()))->preimage); break;
case INTMAT_CMD: Print(" %d x %d\n",((intvec*)(v->Data()))->rows(),
((intvec*)(v->Data()))->cols()); break;
case MATRIX_CMD:Print(" %u x %u\n" ,
MATROWS((matrix)(v->Data())),
MATCOLS((matrix)(v->Data())));break;
case MODUL_CMD: Print(", rk %d\n", (int)(((ideal)(v->Data()))->rank));break;
case LIST_CMD: Print(", size %d\n",((lists)(v->Data()))->nr+1); break;
case PROC_CMD:
case RING_CMD:
case IDEAL_CMD: PrintLn(); break;
//case INT_CMD:
//case STRING_CMD:
//case INTVEC_CMD:
//case POLY_CMD:
//case VECTOR_CMD:
//case PACKAGE_CMD:
default:
break;
}
v->Print();
if (currRing != NULL)
currRing->ShortOut = oldShortOut;
}

## versionString()

char * versionString | ( |  | ) |

Definition at line 769 of file misc_ip.cc.

{
StringSetS("");
StringAppend("Singular for %s version %s (%d, %d bit) %s",
S_UNAME, VERSION, // SINGULAR_VERSION,
SINGULAR_VERSION, sizeof(void*)*8,
#ifdef MAKE_DISTRIBUTION
VERSION_DATE);
#else
singular_date);
#endif
StringAppendS("\nwith\n\t");
#if defined(mpir_version)
StringAppend("MPIR(%s)~GMP(%s),", mpir_version, gmp_version);
#elif defined(gmp_version)
// #if defined (__GNU_MP_VERSION) && defined (__GNU_MP_VERSION_MINOR)
// StringAppend("GMP(%d.%d),",__GNU_MP_VERSION,__GNU_MP_VERSION_MINOR);
StringAppend("GMP(%s),", gmp_version);
#endif
#ifdef HAVE_NTL
StringAppend("NTL(%s),",NTL_VERSION);
#endif
#ifdef HAVE_FLINT
StringAppend("FLINT(%s),",FLINT_VERSION);
#endif
// StringAppendS("factory(" FACTORYVERSION "),");
StringAppendS("\n\t");
#ifndef HAVE_OMALLOC
StringAppendS("xalloc,");
#else
StringAppendS("omalloc,");
#endif
#if defined(HAVE_DYN_RL)
if (fe_fgets_stdin==fe_fgets_dummy)
StringAppendS("no input,");
else if (fe_fgets_stdin==fe_fgets)
StringAppendS("fgets,");
if (fe_fgets_stdin==fe_fgets_stdin_drl)
StringAppend("dynamic readline%d),",RL_VERSION_MAJOR);
#ifdef HAVE_FEREAD
else if (fe_fgets_stdin==fe_fgets_stdin_emu)
StringAppendS("emulated readline,");
#endif
else
StringAppendS("unknown fgets method,");
#else
#if defined(HAVE_READLINE) && !defined(FEREAD)
StringAppend("static readline(%d),",RL_VERSION_MAJOR);
#else
#ifdef HAVE_FEREAD
StringAppendS("emulated readline,");
#else
StringAppendS("fgets,");
#endif
#endif
#endif
#ifdef HAVE_PLURAL
StringAppendS("Plural,");
#endif
#ifdef HAVE_VSPACE
#if defined(__GNUC__) && (__GNUC__<9) &&!defined(__clang__)
StringAppendS("vspace(1),");
#else
StringAppendS("vspace(2),");
#endif
#endif
#ifdef HAVE_DBM
StringAppendS("DBM,\n\t");
#else
StringAppendS("\n\t");
#endif
#ifdef HAVE_DYNAMIC_LOADING
StringAppendS("dynamic modules,");
#endif
#ifdef HAVE_DYNANIC_PPROCS
StringAppendS("dynamic p_Procs,");
#endif
#if YYDEBUG
StringAppendS("YYDEBUG=1,");
#endif
#ifdef MDEBUG
StringAppend("MDEBUG=%d,",MDEBUG);
#endif
#ifdef OM_CHECK
StringAppend("OM_CHECK=%d,",OM_CHECK);
#endif
#ifdef OM_TRACK
StringAppend("OM_TRACK=%d,",OM_TRACK);
#endif
#ifdef OM_NDEBUG
StringAppendS("OM_NDEBUG,");
#endif
#ifdef SING_NDEBUG
StringAppendS("SING_NDEBUG,");
#endif
#ifdef PDEBUG
StringAppendS("PDEBUG,");
#endif
#ifdef KDEBUG
StringAppendS("KDEBUG,");
#endif
#ifdef HAVE_SDB
StringAppendS("sdb,");
#endif
StringAppendS("\n\t");
#ifdef __OPTIMIZE__
StringAppendS("CC:OPTIMIZE,");
#endif
#ifdef __OPTIMIZE_SIZE__
StringAppendS("CC:OPTIMIZE_SIZE,");
#endif
#ifdef __NO_INLINE__
StringAppendS("CC:NO_INLINE,");
#endif
#ifdef HAVE_NTL
#ifdef NTL_AVOID_BRANCHING
#undef HAVE_GENERIC_ADD
#endif
#endif
#ifdef HAVE_GENERIC_ADD
StringAppendS("GenericAdd,");
#else
StringAppendS("AvoidBranching,");
#endif
#ifdef HAVE_GENERIC_MULT
StringAppendS("GenericMult,");
#else
StringAppendS("TableMult,");
#endif
#ifdef HAVE_INVTABLE
StringAppendS("invTable,");
#else
StringAppendS("no invTable,");
#endif
StringAppendS("\n\t");
#ifdef HAVE_EIGENVAL
StringAppendS("eigenvalues,");
#endif
#ifdef HAVE_GMS
StringAppendS("Gauss-Manin system,");
#endif
#ifdef HAVE_RATGRING
StringAppendS("ratGB,");
#endif
StringAppend("random=%d\n",siRandomStart);
#define SI_SHOW_BUILTIN_MODULE(name) StringAppend(" %s", #name);
StringAppendS("built-in modules: {");
SI_FOREACH_BUILTIN(SI_SHOW_BUILTIN_MODULE)
StringAppendS("}\n");
#undef SI_SHOW_BUILTIN_MODULE
StringAppend("AC_CONFIGURE_ARGS = %s,\n"
"CC = %s,FLAGS : %s,\n"
"CXX = %s,FLAGS : %s,\n"
"DEFS : %s,CPPFLAGS : %s,\n"
"LDFLAGS : %s,LIBS : %s "
#ifdef __GNUC__
"(ver: " __VERSION__ ")"
#endif
"\n",AC_CONFIGURE_ARGS, CC,CFLAGS " " PTHREAD_CFLAGS,
CXX,CXXFLAGS " " PTHREAD_CFLAGS, DEFS,CPPFLAGS, LDFLAGS,
LIBS " " PTHREAD_LIBS);
feStringAppendResources(0);
feStringAppendBrowsers(0);
StringAppendS("\n");
return StringEndS();
}
VERSION
#define VERSION
Definition factoryconf.h:277
fe_fgets_dummy
char * fe_fgets_dummy(const char *, char *, int)
Definition feread.cc:455
fe_fgets
char * fe_fgets(const char *pr, char *s, int size)
Definition feread.cc:309
fe_fgets_stdin_drl
char * fe_fgets_stdin_drl(const char *pr, char *s, int size)
Definition feread.cc:269
fe_fgets_stdin_emu
char * fe_fgets_stdin_emu(const char *pr, char *s, int size)
Definition feread.cc:253
SI_SHOW_BUILTIN_MODULE
#define SI_SHOW_BUILTIN_MODULE(name)
singular_date
const char * singular_date
Definition misc_ip.cc:766
MDEBUG
#define MDEBUG
Definition mod2.h:180
SI_FOREACH_BUILTIN
#define SI_FOREACH_BUILTIN(add)
Data for type_of_LIB to determine built-in modules, use add(name) to add built-in library to macro.
Definition mod_lib.h:17
OM_TRACK
#define OM_TRACK
Definition omalloc_debug.c:10
OM_CHECK
#define OM_CHECK
Definition omalloc_debug.c:11
feStringAppendResources
void feStringAppendResources(int warn)
Definition reporter.cc:402

## Variable Documentation

## currid

const char* currid

extern

Definition at line 171 of file grammar.cc.

## dArith1

const struct sValCmd1 dArith1[]

extern

Definition at line 38 of file table.h.

{
// operationsi
// proc cmd res arg context
{D(jjPLUSPLUS), PLUSPLUS, NONE, IDHDL , ALLOW_NC |ALLOW_RING}
,{D(jjPLUSPLUS), MINUSMINUS, NONE, IDHDL , ALLOW_NC |ALLOW_RING}
,{D(jjUMINUS_I), '-', INT_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjUMINUS_BI), '-', BIGINT_CMD, BIGINT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjUMINUS_N), '-', NUMBER_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2_OP1),'-', CNUMBER_CMD, CNUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjPOLY2_OP1), '-', CPOLY_CMD, CPOLY_CMD , ALLOW_NC |ALLOW_RING}
#endif
,{D(jjUMINUS_P), '-', POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjUMINUS_P), '-', VECTOR_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjUMINUS_MA), '-', MATRIX_CMD, MATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjUMINUS_IV), '-', INTVEC_CMD, INTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjUMINUS_IV), '-', INTMAT_CMD, INTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjUMINUS_BIM), '-', BIGINTMAT_CMD, BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjUMINUS_BIM), '-', CMATRIX_CMD, CMATRIX_CMD , ALLOW_NC |ALLOW_RING}
#endif
,{D(jjPROC1), '(', ANY_TYPE/*set by p*/,PROC_CMD , ALLOW_NC |ALLOW_RING}
// and the procedures with 1 argument:
,{D(atATTRIB1), ATTRIB_CMD, NONE, DEF_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjBAREISS_BIM), BAREISS_CMD, BIGINTMAT_CMD, BIGINTMAT_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjBAREISS), BAREISS_CMD, LIST_CMD, MODUL_CMD , NO_NC |ALLOW_RING | NO_ZERODIVISOR}
,{D(jjBETTI), BETTI_CMD, INTMAT_CMD, LIST_CMD , ALLOW_PLURAL |NO_RING}
,{D(syBetti1), BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjBETTI), BETTI_CMD, INTMAT_CMD, IDEAL_CMD , ALLOW_PLURAL |NO_RING}
,{D(jjBETTI), BETTI_CMD, INTMAT_CMD, MODUL_CMD , ALLOW_PLURAL |NO_RING}
,{D(jjDUMMY), BIGINT_CMD, BIGINT_CMD, BIGINT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjN2BI), BIGINT_CMD, BIGINT_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjP2BI), BIGINT_CMD, BIGINT_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), BIGINTMAT_CMD, BIGINTMAT_CMD, BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), BIGINTVEC_CMD, BIGINTVEC_CMD, BIGINTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCHAR), CHARACTERISTIC_CMD, INT_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCHARSERIES), CHAR_SERIES_CMD, MATRIX_CMD, IDEAL_CMD , NO_NC |NO_RING}
,{D(jjrCharStr), CHARSTR_CMD, STRING_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjOpenClose), CLOSE_CMD, NONE, LINK_CMD , ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjDUMMY), CMATRIX_CMD, CMATRIX_CMD, CMATRIX_CMD , ALLOW_NC |ALLOW_RING}
#endif
//,{ jjWRONG , COLS_CMD, 0, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOEFFS1), COEFFS_CMD, CRING_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOLS), COLS_CMD, INT_CMD, MATRIX_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjCOLS), COLS_CMD, INT_CMD, SMATRIX_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjCOLS), COLS_CMD, INT_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjCOLS), COLS_CMD, INT_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjCOLS_IV), COLS_CMD, INT_CMD, INTMAT_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjCOLS_BIM), COLS_CMD, INT_CMD, BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
#ifdef SINGULAR_4_2
,{D(jjCOLS_BIM), COLS_CMD, INT_CMD, CMATRIX_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
#endif
//,{ jjWRONG , COLS_CMD, 0, INTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCONTENT), CONTENT_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCONTENT), CONTENT_CMD, VECTOR_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_BI), COUNT_CMD, INT_CMD, BIGINT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_N), COUNT_CMD, INT_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_RES), COUNT_CMD, INT_CMD, RESOLUTION_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjstrlen), COUNT_CMD, INT_CMD, STRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjpLength), COUNT_CMD, INT_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjpLength), COUNT_CMD, INT_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidElem), COUNT_CMD, INT_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidElem), COUNT_CMD, INT_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_M), COUNT_CMD, INT_CMD, MATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_IV), COUNT_CMD, INT_CMD, INTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_IV), COUNT_CMD, INT_CMD, INTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_BIM), COUNT_CMD, INT_CMD, BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_BIM), COUNT_CMD, INT_CMD, BIGINTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_L), COUNT_CMD, INT_CMD, LIST_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCOUNT_RG), COUNT_CMD, INT_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjR2_CR), CRING_CMD, CRING_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjNULL), DEF_CMD, DEF_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{ jjWRONG , DEF_CMD, 0, ANY_TYPE , ALLOW_NC |ALLOW_RING}
,{D(jjDEG), DEG_CMD, INT_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDEG), DEG_CMD, INT_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDEG_M), DEG_CMD, INT_CMD, MATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDEGREE), DEGREE_CMD, STRING_CMD, IDEAL_CMD , NO_NC |ALLOW_RING | NO_ZERODIVISOR}
,{D(jjDEGREE), DEGREE_CMD, STRING_CMD, MODUL_CMD , NO_NC |ALLOW_RING | NO_ZERODIVISOR}
,{D(jjDEFINED), DEFINED_CMD, INT_CMD, DEF_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDENOMINATOR),DENOMINATOR_CMD, NUMBER_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjNUMERATOR), NUMERATOR_CMD, NUMBER_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjDET_N2), DET_CMD, CNUMBER_CMD, CMATRIX_CMD , ALLOW_PLURAL |ALLOW_RING}
#endif
,{D(jjDET_BI), DET_CMD, BIGINT_CMD, BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDET_I), DET_CMD, INT_CMD, INTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDET_S), DET_CMD, POLY_CMD, SMATRIX_CMD , NO_NC |NO_RING}
,{D(jjDET), DET_CMD, POLY_CMD, MATRIX_CMD , NO_NC |ALLOW_RING}
,{D(jjDIM), DIM_CMD, INT_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDIM), DIM_CMD, INT_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIM_R), DIM_CMD, INT_CMD, RESOLUTION_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDUMP), DUMP_CMD, NONE, LINK_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjE), E_CMD, VECTOR_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjEXECUTE), EXECUTE_CMD, NONE, STRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjERROR), ERROR_CMD, NONE, STRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjFAC_P), FAC_CMD, LIST_CMD, POLY_CMD , NO_NC |ALLOW_ZZ}
,{D(findUniProc), FINDUNI_CMD, IDEAL_CMD, IDEAL_CMD , NO_NC |NO_RING}
,{D(jjidFreeModule),FREEMODULE_CMD, MODUL_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjFACSTD), FACSTD_CMD, LIST_CMD, IDEAL_CMD , NO_NC |NO_RING}
,{D(jjGETDUMP), GETDUMP_CMD, NONE, LINK_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjHIGHCORNER), HIGHCORNER_CMD, POLY_CMD, IDEAL_CMD , NO_NC |ALLOW_RING}
,{D(jjHIGHCORNER_M), HIGHCORNER_CMD,VECTOR_CMD, MODUL_CMD , NO_NC |ALLOW_RING}
,{D(jjHILBERT), HILBERT_CMD, NONE, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHILBERT), HILBERT_CMD, NONE, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHILBERT_IV), HILBERT_CMD, INTVEC_CMD, INTVEC_CMD , ALLOW_PLURAL |ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHOMOG1), HOMOG_CMD, INT_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjHOMOG1), HOMOG_CMD, INT_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), IDEAL_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidVec2Ideal),IDEAL_CMD, IDEAL_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjIDEAL_Ma), IDEAL_CMD, IDEAL_CMD, MATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjIDEAL_R), IDEAL_CMD, IDEAL_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjIDEAL_Map), IDEAL_CMD, IDEAL_CMD, MAP_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjIMPART), IMPART_CMD, NUMBER_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjINDEPSET), INDEPSET_CMD, INTVEC_CMD, IDEAL_CMD , NO_NC |NO_RING}
,{D(jjDUMMY), INT_CMD, INT_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjnlInt), INT_CMD, INT_CMD, BIGINT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjnInt), INT_CMD, INT_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjP2I), INT_CMD, INT_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjS2I), INT_CMD, INT_CMD, STRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjINTERRED), INTERRED_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjINTERRED), INTERRED_CMD, MODUL_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjBI2IM), INTMAT_CMD, INTMAT_CMD, BIGINTMAT_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjDUMMY), INTMAT_CMD, INTMAT_CMD, INTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjIm2Iv), INTVEC_CMD, INTVEC_CMD, INTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), INTVEC_CMD, INTVEC_CMD, INTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjBIV2IV), INTVEC_CMD, INTVEC_CMD, BIGINTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjIS_RINGVAR_P), IS_RINGVAR, INT_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjIS_RINGVAR_S), IS_RINGVAR, INT_CMD, STRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjIS_RINGVAR0),IS_RINGVAR, INT_CMD, ANY_TYPE , ALLOW_NC |ALLOW_RING}
,{D(jjJACOB_P), JACOB_CMD, IDEAL_CMD, POLY_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(mpJacobi), JACOB_CMD, MATRIX_CMD, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjJACOB_M), JACOB_CMD, MODUL_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjJanetBasis), JANET_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_PLURAL |NO_RING}
,{D(jjKBASE), KBASE_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING|WARN_RING} /*ring-cf: warning at top level*/
,{D(jjKBASE), KBASE_CMD, MODUL_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING|WARN_RING} /*ring-cf: warning at top level*/
,{D(jjKERNEL_M), KERNEL_CMD, MATRIX_CMD, MATRIX_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjKERNEL_SM), KERNEL_CMD, SMATRIX_CMD, SMATRIX_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjLagSolve), LAGSOLVE_CMD, LIST_CMD, POLY_CMD , NO_NC |NO_RING}
,{D(jjLU_DECOMP), LU_CMD, LIST_CMD, MATRIX_CMD , NO_NC |NO_RING}
,{D(jjPFAC1), PFAC_CMD, LIST_CMD, BIGINT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjPFAC1), PFAC_CMD, LIST_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(atKILLATTR1), KILLATTR_CMD, NONE, IDHDL , ALLOW_NC |ALLOW_RING}
,{D(jjpHead), LEAD_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidHead), LEAD_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjpHead), LEAD_CMD, VECTOR_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidHead), LEAD_CMD, MODUL_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjLEADCOEF), LEADCOEF_CMD, NUMBER_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjLEADCOEF), LEADCOEF_CMD, NUMBER_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjLEADEXP), LEADEXP_CMD, INTVEC_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjLEADEXP), LEADEXP_CMD, INTVEC_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjLEADMONOM), LEADMONOM_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjLEADMONOM), LEADMONOM_CMD, VECTOR_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), LINK_CMD, LINK_CMD, LINK_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCALL1MANY), LIST_CMD, LIST_CMD, DEF_CMD , ALLOW_NC |ALLOW_RING}
,{ jjWRONG , MAP_CMD, 0, ANY_TYPE , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), MATRIX_CMD, MATRIX_CMD, MATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidMaxIdeal), MAXID_CMD, IDEAL_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjMEMORY), MEMORY_CMD, BIGINT_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidMinBase), MINBASE_CMD, IDEAL_CMD, IDEAL_CMD , NO_NC |NO_RING}
,{D(jjidMinBase), MINBASE_CMD, MODUL_CMD, MODUL_CMD , NO_NC |NO_RING}
,{D(jjMINRES), MINRES_CMD, LIST_CMD, LIST_CMD , ALLOW_PLURAL |NO_RING}
,{D(jjMINRES_R), MINRES_CMD, RESOLUTION_CMD, RESOLUTION_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjDUMMY), MODUL_CMD, MODUL_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjMONITOR1), MONITOR_CMD, NONE, LINK_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjMONOM), MONOM_CMD, POLY_CMD, INTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjMULT), MULTIPLICITY_CMD, INT_CMD, IDEAL_CMD , NO_NC |ALLOW_RING}
,{D(jjMULT), MULTIPLICITY_CMD, INT_CMD, MODUL_CMD , NO_NC |ALLOW_RING}
,{D(jjMSTD), MSTD_CMD, LIST_CMD, IDEAL_CMD , NO_NC |ALLOW_RING}
,{D(jjMSTD), MSTD_CMD, LIST_CMD, MODUL_CMD , NO_NC |ALLOW_RING}
,{D(jjNAMEOF), NAMEOF_CMD, STRING_CMD, ANY_TYPE , ALLOW_NC |ALLOW_RING}
,{D(jjNAMES_I), NAMES_CMD, LIST_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjNAMES), NAMES_CMD, LIST_CMD, PACKAGE_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjNAMES), NAMES_CMD, LIST_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjNOT), NOT, INT_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjN2_N), NUMBER_CMD, NUMBER_CMD, CNUMBER_CMD , ALLOW_NC |ALLOW_RING}
#endif
,{D(jjDUMMY), NUMBER_CMD, NUMBER_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjP2N), NUMBER_CMD, NUMBER_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjBI2N), NUMBER_CMD, NUMBER_CMD, BIGINT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), CNUMBER_CMD, CNUMBER_CMD, CNUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjRPAR), NPARS_CMD, INT_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjNVARS), NVARS_CMD, INT_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjOpenClose), OPEN_CMD, NONE, LINK_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCALL1MANY), OPTION_CMD, NONE, DEF_CMD , ALLOW_NC |ALLOW_RING} /*libsing*/
,{D(jjORD), ORD_CMD, INT_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjORD), ORD_CMD, INT_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjrOrdStr), ORDSTR_CMD, STRING_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjPAR1), PAR_CMD, NUMBER_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjPARDEG), PARDEG_CMD, INT_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjN2_CR), PARENT_CMD, CRING_CMD, CNUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjP2_R), PARENT_CMD, RING_CMD, CPOLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjCM_CR), PARENT_CMD, CRING_CMD, CMATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjBIM2_CR), PARENT_CMD, CRING_CMD, BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING}
#endif
,{D(jjPARSTR1), PARSTR_CMD, STRING_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjrParStr), PARSTR_CMD, STRING_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), POLY_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjBI2P), POLY_CMD, POLY_CMD, BIGINT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjPREIMAGE_R), PREIMAGE_CMD, RING_CMD, MAP_CMD , ALLOW_LP |ALLOW_RING}
,{D(jjPRIME), PRIME_CMD, INT_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjPRINT), PRINT_CMD, STRING_CMD, LIST_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjPRINT), PRINT_CMD, STRING_CMD, DEF_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), PROC_CMD, PROC_CMD, PROC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjPRUNE), PRUNE_CMD, MODUL_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(kQHWeight), QHWEIGHT_CMD, INTVEC_CMD, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(kQHWeight), QHWEIGHT_CMD, INTVEC_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjRANK1), RANK_CMD, INT_CMD, MATRIX_CMD , ALLOW_NC |NO_RING}
,{D(jjREAD), READ_CMD, STRING_CMD, LINK_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjREGULARITY), REGULARITY_CMD, INT_CMD, LIST_CMD , NO_NC |ALLOW_RING}
,{D(jjREPART), REPART_CMD, NUMBER_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjRESERVEDNAME),RESERVEDNAME_CMD, INT_CMD, STRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjL2R), RESOLUTION_CMD, RESOLUTION_CMD, LIST_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjDUMMY), RESOLUTION_CMD, RESOLUTION_CMD, RESOLUTION_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjRESTART), RESTART_CMD, NONE, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjRIGHTSTD), RIGHTSTD_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_NC |NO_RING}
,{D(jjRINGLIST), RINGLIST_CMD, LIST_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjRINGLIST_C), RING_LIST_CMD, LIST_CMD, CRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjRING_LIST), RING_LIST_CMD, LIST_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), RING_CMD, RING_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjLISTRING), RING_CMD, RING_CMD, LIST_CMD , ALLOW_NC |ALLOW_RING}
//,{ jjWRONG , ROWS_CMD, 0, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjpMaxComp), ROWS_CMD, INT_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjROWS), ROWS_CMD, INT_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjROWS), ROWS_CMD, INT_CMD, MATRIX_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjROWS), ROWS_CMD, INT_CMD, SMATRIX_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjROWS_IV), ROWS_CMD, INT_CMD, INTMAT_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjROWS_BIM), ROWS_CMD, INT_CMD, BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
#ifdef SINGULAR_4_2
,{D(jjROWS_BIM), ROWS_CMD, INT_CMD, CMATRIX_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
#endif
,{D(jjCOUNT_IV), ROWS_CMD, INT_CMD, INTVEC_CMD , ALLOW_NC |ALLOW_RING|NO_CONVERSION}
,{D(jjSBA), SBA_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjSBA), SBA_CMD, MODUL_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjSetRing), SETRING_CMD, NONE, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSLIM_GB), SLIM_GB_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_PLURAL |NO_RING}
,{D(jjSLIM_GB), SLIM_GB_CMD, MODUL_CMD, MODUL_CMD , ALLOW_PLURAL |NO_RING}
,{D(jjDUMMY), SMATRIX_CMD, SMATRIX_CMD, SMATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSort_Id), SORTVEC_CMD, INTVEC_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSort_Id), SORTVEC_CMD, INTVEC_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSQR_FREE), SQR_FREE_CMD, LIST_CMD, POLY_CMD , NO_NC |NO_RING}
,{D(jjSTD), STD_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSTD), STD_CMD, MODUL_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSTD), STD_CMD, SMATRIX_CMD, SMATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjDUMMY), STRING_CMD, STRING_CMD, STRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSYZYGY), SYZYGY_CMD, MODUL_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING |NO_LRING}
,{D(jjSYZYGY), SYZYGY_CMD, MODUL_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING |NO_LRING}
,{D(jjENVELOPE), ENVELOPE_CMD, RING_CMD, RING_CMD , ALLOW_PLURAL |NO_RING}
,{D(jjOPPOSITE), OPPOSITE_CMD, RING_CMD, RING_CMD , ALLOW_PLURAL |NO_RING}
,{D(jjTWOSTD), TWOSTD_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjTWOSTD), TWOSTD_CMD, MODUL_CMD, MODUL_CMD , ALLOW_LP |ALLOW_RING}
//,{ jjWRONG , TRACE_CMD, 0, INTVEC_CMD , ALLOW_NC |ALLOW_RING}
//,{ jjWRONG , TRACE_CMD, 0, IDEAL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjTRACE_IV), TRACE_CMD, INT_CMD, INTMAT_CMD , ALLOW_PLURAL |ALLOW_RING|NO_CONVERSION}
,{D(jjmpTrace), TRACE_CMD, POLY_CMD, MATRIX_CMD , ALLOW_PLURAL |ALLOW_RING|NO_CONVERSION}
,{D(jjTRANSP_IV), TRANSPOSE_CMD, INTMAT_CMD, INTVEC_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjTRANSP_IV), TRANSPOSE_CMD, INTMAT_CMD, INTMAT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjTRANSP_BIM), TRANSPOSE_CMD, BIGINTMAT_CMD, BIGINTMAT_CMD , ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjTRANSP_BIM), TRANSPOSE_CMD, CMATRIX_CMD, CMATRIX_CMD , ALLOW_NC |ALLOW_RING}
#endif
,{D(jjmpTransp), TRANSPOSE_CMD, MATRIX_CMD, MATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidTransp), TRANSPOSE_CMD, MODUL_CMD, MODUL_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjidTransp), TRANSPOSE_CMD, SMATRIX_CMD, SMATRIX_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjTYPEOF), TYPEOF_CMD, STRING_CMD, ANY_TYPE , ALLOW_NC |ALLOW_RING}
,{D(jjUNIVARIATE), UNIVARIATE_CMD, INT_CMD, POLY_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjVARIABLES_P),VARIABLES_CMD, IDEAL_CMD, POLY_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjVARIABLES_ID),VARIABLES_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjVARIABLES_ID),VARIABLES_CMD, IDEAL_CMD, MATRIX_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjDUMMY), VECTOR_CMD, VECTOR_CMD, VECTOR_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjVDIM), VDIM_CMD, INT_CMD, IDEAL_CMD , ALLOW_NC |ALLOW_RING |WARN_RING} /*ring-cf: warning at top level*/
,{D(jjVDIM), VDIM_CMD, INT_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING |WARN_RING} /*ring-cf: warning at top level*/
,{D(jjVAR1), VAR_CMD, POLY_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjVARSTR1), VARSTR_CMD, STRING_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjrVarStr), VARSTR_CMD, STRING_CMD, RING_CMD , ALLOW_NC |ALLOW_RING}
,{D(kWeight), WEIGHT_CMD, INTVEC_CMD, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(kWeight), WEIGHT_CMD, INTVEC_CMD, MODUL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjLOAD1), LOAD_CMD, NONE, STRING_CMD , ALLOW_NC |ALLOW_RING}
,{D(loNewtonP), NEWTONPOLY_CMD, IDEAL_CMD, IDEAL_CMD , ALLOW_PLURAL |ALLOW_RING}
,{D(jjWAIT1ST1), WAIT1ST_CMD, INT_CMD, LIST_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjWAITALL1), WAITALL_CMD, INT_CMD, LIST_CMD , ALLOW_NC |ALLOW_RING}
,{NULL_VAL, 0, 0, 0 , NO_NC |NO_RING}
};
atKILLATTR1
BOOLEAN atKILLATTR1(leftv, leftv a)
Definition attrib.cc:476
atATTRIB1
BOOLEAN atATTRIB1(leftv res, leftv v)
Definition attrib.cc:234
findUniProc
BOOLEAN findUniProc(leftv result, leftv first)
Definition fglm.cc:541
NO_ZERODIVISOR
#define NO_ZERODIVISOR
Definition gentable.cc:42
ALLOW_ZZ
#define ALLOW_ZZ
Definition gentable.cc:46
ALLOW_RING
#define ALLOW_RING
Definition gentable.cc:38
NO_LRING
#define NO_LRING
Definition gentable.cc:54
ALLOW_LP
#define ALLOW_LP
Definition gentable.cc:33
NO_RING
#define NO_RING
Definition gentable.cc:39
D
#define D(A)
Definition gentable.cc:128
WARN_RING
#define WARN_RING
Definition gentable.cc:49
ALLOW_NC
#define ALLOW_NC
Definition gentable.cc:35
ALLOW_PLURAL
#define ALLOW_PLURAL
Definition gentable.cc:30
NO_NC
#define NO_NC
Definition gentable.cc:29
NULL_VAL
#define NULL_VAL
Definition gentable.cc:129
NOT
@ NOT
Definition grammar.cc:272
PAR_CMD
@ PAR_CMD
Definition grammar.cc:303
PREIMAGE_CMD
@ PREIMAGE_CMD
Definition grammar.cc:304
SETRING_CMD
@ SETRING_CMD
Definition grammar.cc:330
MONOM_CMD
@ MONOM_CMD
Definition grammar.cc:302
VAR_CMD
@ VAR_CMD
Definition grammar.cc:305
MAXID_CMD
@ MAXID_CMD
Definition grammar.cc:301
E_CMD
@ E_CMD
Definition grammar.cc:295
FREEMODULE_CMD
@ FREEMODULE_CMD
Definition grammar.cc:297
BETTI_CMD
@ BETTI_CMD
Definition grammar.cc:294
jjUMINUS_MA
static BOOLEAN jjUMINUS_MA(leftv res, leftv u)
Definition iparith.cc:3834
jjRANK1
static BOOLEAN jjRANK1(leftv res, leftv v)
Definition iparith.cc:4964
jjIMPART
static BOOLEAN jjIMPART(leftv res, leftv v)
Definition iparith.cc:4461
jjIm2Iv
static BOOLEAN jjIm2Iv(leftv res, leftv v)
Definition iparith.cc:4454
jjUMINUS_IV
static BOOLEAN jjUMINUS_IV(leftv res, leftv u)
Definition iparith.cc:3840
jjOPPOSITE
static BOOLEAN jjOPPOSITE(leftv res, leftv a)
Definition iparith.cc:5310
jjWAITALL1
BOOLEAN jjWAITALL1(leftv res, leftv u)
Definition iparith.cc:5556
jjRESTART
static BOOLEAN jjRESTART(leftv, leftv u)
Definition iparith.cc:8977
jjidHead
static BOOLEAN jjidHead(leftv res, leftv v)
Definition iparith.cc:5718
jjHILBERT
static BOOLEAN jjHILBERT(leftv, leftv v)
Definition iparith.cc:4345
jjLEADMONOM
static BOOLEAN jjLEADMONOM(leftv res, leftv v)
Definition iparith.cc:4620
jjstrlen
static BOOLEAN jjstrlen(leftv res, leftv v)
Definition iparith.cc:5683
jjDET_BI
static BOOLEAN jjDET_BI(leftv res, leftv v)
Definition iparith.cc:4102
jjWAIT1ST1
BOOLEAN jjWAIT1ST1(leftv res, leftv u)
Definition iparith.cc:5541
jjP2I
static BOOLEAN jjP2I(leftv res, leftv v)
Definition iparith.cc:4878
jjIS_RINGVAR_P
static BOOLEAN jjIS_RINGVAR_P(leftv res, leftv v)
Definition iparith.cc:4488
jjREPART
static BOOLEAN jjREPART(leftv res, leftv v)
Definition iparith.cc:4980
jjN2BI
static BOOLEAN jjN2BI(leftv res, leftv v)
Definition iparith.cc:4761
jjCHAR
static BOOLEAN jjCHAR(leftv res, leftv v)
Definition iparith.cc:3949
jjROWS_IV
static BOOLEAN jjROWS_IV(leftv res, leftv v)
Definition iparith.cc:5025
jjNULL
static BOOLEAN jjNULL(leftv, leftv)
Definition iparith.cc:3784
jjBIV2IV
static BOOLEAN jjBIV2IV(leftv res, leftv v)
Definition iparith.cc:4479
jjDIM
static BOOLEAN jjDIM(leftv res, leftv v)
Definition iparith.cc:4158
jjCOUNT_BIM
static BOOLEAN jjCOUNT_BIM(leftv res, leftv v)
Definition iparith.cc:3989
jjCOLS_IV
static BOOLEAN jjCOLS_IV(leftv res, leftv v)
Definition iparith.cc:3971
jjNAMES_I
static BOOLEAN jjNAMES_I(leftv res, leftv v)
Definition iparith.cc:4791
jjMULT
static BOOLEAN jjMULT(leftv res, leftv v)
Definition iparith.cc:4741
jjPARDEG
static BOOLEAN jjPARDEG(leftv res, leftv v)
Definition iparith.cc:4834
jjDENOMINATOR
static BOOLEAN jjDENOMINATOR(leftv res, leftv v)
Return the denominator of the input number.
Definition iparith.cc:4079
jjIDEAL_Ma
static BOOLEAN jjIDEAL_Ma(leftv res, leftv v)
Definition iparith.cc:4418
jjmpTransp
static BOOLEAN jjmpTransp(leftv res, leftv v)
Definition iparith.cc:5746
jjDET_S
static BOOLEAN jjDET_S(leftv res, leftv v)
Definition iparith.cc:4152
jjL2R
static BOOLEAN jjL2R(leftv res, leftv v)
Definition iparith.cc:4580
jjrCharStr
static BOOLEAN jjrCharStr(leftv res, leftv v)
Definition iparith.cc:5708
jjHILBERT_IV
static BOOLEAN jjHILBERT_IV(leftv res, leftv v)
Definition iparith.cc:4358
jjIDEAL_R
static BOOLEAN jjIDEAL_R(leftv res, leftv v)
Definition iparith.cc:4437
jjINDEPSET
static BOOLEAN jjINDEPSET(leftv res, leftv v)
Definition iparith.cc:4466
jjTYPEOF
static BOOLEAN jjTYPEOF(leftv res, leftv v)
Definition iparith.cc:5426
jjFACSTD
static BOOLEAN jjFACSTD(leftv res, leftv v)
Definition iparith.cc:4221
jjMEMORY
static BOOLEAN jjMEMORY(leftv res, leftv v)
Definition iparith.cc:4696
jjidTransp
static BOOLEAN jjidTransp(leftv res, leftv v)
Definition iparith.cc:5776
jjUMINUS_BIM
static BOOLEAN jjUMINUS_BIM(leftv res, leftv u)
Definition iparith.cc:3847
jjDIM_R
static BOOLEAN jjDIM_R(leftv res, leftv v)
Definition iparith.cc:5771
jjDUMP
static BOOLEAN jjDUMP(leftv, leftv v)
Definition iparith.cc:4186
jjpMaxComp
static BOOLEAN jjpMaxComp(leftv res, leftv v)
Definition iparith.cc:5736
jjCOEFFS1
static BOOLEAN jjCOEFFS1(leftv res, leftv v)
Definition iparith.cc:3954
jjNAMEOF
static BOOLEAN jjNAMEOF(leftv res, leftv v)
Definition iparith.cc:4773
jjPRIME
static BOOLEAN jjPRIME(leftv res, leftv v)
Definition iparith.cc:4896
jjidVec2Ideal
static BOOLEAN jjidVec2Ideal(leftv res, leftv v)
Definition iparith.cc:5703
jjJACOB_P
static BOOLEAN jjJACOB_P(leftv res, leftv v)
Definition iparith.cc:4504
jjSQR_FREE
static BOOLEAN jjSQR_FREE(leftv res, leftv u)
Definition iparith.cc:5197
jjCALL1MANY
static BOOLEAN jjCALL1MANY(leftv res, leftv u)
Definition iparith.cc:3945
jjINTERRED
static BOOLEAN jjINTERRED(leftv res, leftv v)
Definition iparith.cc:4472
jjJACOB_M
static BOOLEAN jjJACOB_M(leftv res, leftv a)
Definition iparith.cc:4535
jjBAREISS
static BOOLEAN jjBAREISS(leftv res, leftv v)
Definition iparith.cc:3879
jjREAD
static BOOLEAN jjREAD(leftv res, leftv v)
Definition iparith.cc:4971
jjIS_RINGVAR_S
static BOOLEAN jjIS_RINGVAR_S(leftv res, leftv v)
Definition iparith.cc:4493
jjROWS_BIM
static BOOLEAN jjROWS_BIM(leftv res, leftv v)
Definition iparith.cc:5020
jjSLIM_GB
static BOOLEAN jjSLIM_GB(leftv res, leftv u)
Definition iparith.cc:5040
jjMSTD
static BOOLEAN jjMSTD(leftv res, leftv v)
Definition iparith.cc:4726
jjnInt
static BOOLEAN jjnInt(leftv res, leftv u)
Definition iparith.cc:5781
jjREGULARITY
static BOOLEAN jjREGULARITY(leftv res, leftv v)
Definition iparith.cc:4975
jjTRACE_IV
static BOOLEAN jjTRACE_IV(leftv res, leftv v)
Definition iparith.cc:5295
jjMONOM
static BOOLEAN jjMONOM(leftv res, leftv v)
Definition iparith.cc:2783
jjSort_Id
static BOOLEAN jjSort_Id(leftv res, leftv v)
Definition iparith.cc:5192
jjidMinBase
static BOOLEAN jjidMinBase(leftv res, leftv v)
Definition iparith.cc:5724
jjPREIMAGE_R
static BOOLEAN jjPREIMAGE_R(leftv res, leftv v)
Definition iparith.cc:4890
jjidMaxIdeal
static BOOLEAN jjidMaxIdeal(leftv res, leftv v)
Definition iparith.cc:4401
jjCOUNT_BI
static BOOLEAN jjCOUNT_BI(leftv res, leftv v)
Definition iparith.cc:3984
jjKERNEL_M
static BOOLEAN jjKERNEL_M(leftv res, leftv v)
Definition iparith.cc:4556
jjCOLS_BIM
static BOOLEAN jjCOLS_BIM(leftv res, leftv v)
Definition iparith.cc:3966
jjIDEAL_Map
static BOOLEAN jjIDEAL_Map(leftv res, leftv v)
Definition iparith.cc:4427
jjEXECUTE
static BOOLEAN jjEXECUTE(leftv, leftv v)
Definition iparith.cc:4212
jjLEADEXP
static BOOLEAN jjLEADEXP(leftv res, leftv v)
Definition iparith.cc:4602
jjDEG_M
static BOOLEAN jjDEG_M(leftv res, leftv u)
Definition iparith.cc:4039
jjPAR1
static BOOLEAN jjPAR1(leftv res, leftv v)
Definition iparith.cc:4818
jjnlInt
static BOOLEAN jjnlInt(leftv res, leftv u)
Definition iparith.cc:5788
jjPLUSPLUS
static BOOLEAN jjPLUSPLUS(leftv, leftv u)
Definition iparith.cc:3798
jjROWS
static BOOLEAN jjROWS(leftv res, leftv v)
Definition iparith.cc:5014
jjSBA
static BOOLEAN jjSBA(leftv res, leftv v)
Definition iparith.cc:5082
jjJanetBasis
static BOOLEAN jjJanetBasis(leftv res, leftv v)
Definition iparith.cc:2545
jjKBASE
static BOOLEAN jjKBASE(leftv res, leftv v)
Definition iparith.cc:4574
jjmpTrace
static BOOLEAN jjmpTrace(leftv res, leftv v)
Definition iparith.cc:5741
jjPRUNE
static BOOLEAN jjPRUNE(leftv res, leftv v)
Definition iparith.cc:4902
jjDEFINED
static BOOLEAN jjDEFINED(leftv res, leftv v)
Definition iparith.cc:4067
jjLagSolve
static BOOLEAN jjLagSolve(leftv res, leftv v)
Definition iparith.cc:4657
jjVDIM
static BOOLEAN jjVDIM(leftv res, leftv v)
Definition iparith.cc:5514
jjCOUNT_N
static BOOLEAN jjCOUNT_N(leftv res, leftv v)
Definition iparith.cc:3995
jjP2N
static BOOLEAN jjP2N(leftv res, leftv v)
Definition iparith.cc:4926
jjE
static BOOLEAN jjE(leftv res, leftv v)
Definition iparith.cc:4200
jjLISTRING
static BOOLEAN jjLISTRING(leftv res, leftv v)
Definition iparith.cc:4639
jjVAR1
static BOOLEAN jjVAR1(leftv res, leftv v)
Definition iparith.cc:5480
jjLEADCOEF
static BOOLEAN jjLEADCOEF(leftv res, leftv v)
Definition iparith.cc:4588
jjUMINUS_BI
static BOOLEAN jjUMINUS_BI(leftv res, leftv u)
Definition iparith.cc:3810
jjpLength
static BOOLEAN jjpLength(leftv res, leftv v)
Definition iparith.cc:5688
jjIS_RINGVAR0
static BOOLEAN jjIS_RINGVAR0(leftv res, leftv)
Definition iparith.cc:4499
jjBI2P
static BOOLEAN jjBI2P(leftv res, leftv u)
Definition iparith.cc:3930
jjTWOSTD
static BOOLEAN jjTWOSTD(leftv res, leftv a)
Definition iparith.cc:5344
jjFAC_P
static BOOLEAN jjFAC_P(leftv res, leftv u)
Definition iparith.cc:4261
jjTRANSP_BIM
static BOOLEAN jjTRANSP_BIM(leftv res, leftv v)
Definition iparith.cc:5300
jjCOUNT_RES
static BOOLEAN jjCOUNT_RES(leftv res, leftv v)
Definition iparith.cc:5766
jjrOrdStr
static BOOLEAN jjrOrdStr(leftv res, leftv v)
Definition iparith.cc:5751
jjpHead
static BOOLEAN jjpHead(leftv res, leftv v)
Definition iparith.cc:5713
jjCOUNT_L
static BOOLEAN jjCOUNT_L(leftv res, leftv v)
Definition iparith.cc:4000
jjDET_I
static BOOLEAN jjDET_I(leftv res, leftv v)
Definition iparith.cc:4138
jjCOUNT_RG
static BOOLEAN jjCOUNT_RG(leftv res, leftv v)
Definition iparith.cc:4017
jjrVarStr
static BOOLEAN jjrVarStr(leftv res, leftv v)
Definition iparith.cc:5756
jjMONITOR1
static BOOLEAN jjMONITOR1(leftv res, leftv v)
Definition iparith.cc:2738
jjUMINUS_N
static BOOLEAN jjUMINUS_N(leftv res, leftv u)
Definition iparith.cc:3822
jjNUMERATOR
static BOOLEAN jjNUMERATOR(leftv res, leftv v)
Return the numerator of the input number.
Definition iparith.cc:4088
jjORD
static BOOLEAN jjORD(leftv res, leftv v)
Definition iparith.cc:4812
jjUMINUS_I
static BOOLEAN jjUMINUS_I(leftv res, leftv u)
Definition iparith.cc:3817
jjENVELOPE
static BOOLEAN jjENVELOPE(leftv res, leftv a)
Definition iparith.cc:5329
jjSetRing
static BOOLEAN jjSetRing(leftv, leftv u)
Definition iparith.cc:3855
jjMINRES_R
static BOOLEAN jjMINRES_R(leftv res, leftv v)
Definition iparith.cc:4747
jjCOLS
static BOOLEAN jjCOLS(leftv res, leftv v)
Definition iparith.cc:3961
jjP2BI
static BOOLEAN jjP2BI(leftv res, leftv v)
Definition iparith.cc:4858
jjTRANSP_IV
static BOOLEAN jjTRANSP_IV(leftv res, leftv v)
Definition iparith.cc:5305
jjUNIVARIATE
static BOOLEAN jjUNIVARIATE(leftv res, leftv v)
Definition iparith.cc:5475
jjBAREISS_BIM
static BOOLEAN jjBAREISS_BIM(leftv res, leftv v)
Definition iparith.cc:3902
jjPFAC1
static BOOLEAN jjPFAC1(leftv res, leftv v)
Definition iparith.cc:4648
jjCONTENT
static BOOLEAN jjCONTENT(leftv res, leftv v)
Definition iparith.cc:3976
jjSTD
static BOOLEAN jjSTD(leftv res, leftv v)
Definition iparith.cc:5163
jjCOUNT_IV
static BOOLEAN jjCOUNT_IV(leftv res, leftv v)
Definition iparith.cc:4012
jjDUMMY
static BOOLEAN jjDUMMY(leftv res, leftv u)
Definition iparith.cc:3777
jjS2I
static BOOLEAN jjS2I(leftv res, leftv v)
Definition iparith.cc:5035
jjBI2N
static BOOLEAN jjBI2N(leftv res, leftv u)
Definition iparith.cc:3909
jjRIGHTSTD
static BOOLEAN jjRIGHTSTD(leftv res, leftv v)
Definition iparith.cc:5363
jjGETDUMP
static BOOLEAN jjGETDUMP(leftv, leftv v)
Definition iparith.cc:4277
jjidFreeModule
static BOOLEAN jjidFreeModule(leftv res, leftv v)
Definition iparith.cc:5698
jjRESERVEDNAME
static BOOLEAN jjRESERVEDNAME(leftv res, leftv v)
Definition iparith.cc:4942
jjRPAR
static BOOLEAN jjRPAR(leftv res, leftv v)
Definition iparith.cc:5030
jjLOAD1
static BOOLEAN jjLOAD1(leftv, leftv v)
Definition iparith.cc:4635
jjKERNEL_SM
static BOOLEAN jjKERNEL_SM(leftv res, leftv v)
Definition iparith.cc:4565
jjrParStr
static BOOLEAN jjrParStr(leftv res, leftv v)
Definition iparith.cc:5761
jjDEG
static BOOLEAN jjDEG(leftv res, leftv v)
Definition iparith.cc:4031
jjRINGLIST
static BOOLEAN jjRINGLIST(leftv res, leftv v)
Definition iparith.cc:4985
jjidElem
static BOOLEAN jjidElem(leftv res, leftv v)
Definition iparith.cc:5693
jjBI2IM
static BOOLEAN jjBI2IM(leftv res, leftv u)
Definition iparith.cc:3924
jjDEGREE
static BOOLEAN jjDEGREE(leftv res, leftv v)
Definition iparith.cc:4050
jjOpenClose
static BOOLEAN jjOpenClose(leftv, leftv v)
Definition iparith.cc:4806
jjUMINUS_P
static BOOLEAN jjUMINUS_P(leftv res, leftv u)
Definition iparith.cc:3829
jjHIGHCORNER_M
static BOOLEAN jjHIGHCORNER_M(leftv res, leftv v)
Definition iparith.cc:4298
jjNAMES
static BOOLEAN jjNAMES(leftv res, leftv v)
Definition iparith.cc:4786
jjHIGHCORNER
static BOOLEAN jjHIGHCORNER(leftv res, leftv v)
Definition iparith.cc:4291
jjPROC1
static BOOLEAN jjPROC1(leftv res, leftv u)
Definition iparith.cc:3875
jjNOT
static BOOLEAN jjNOT(leftv res, leftv v)
Definition iparith.cc:4796
jjPARSTR1
static BOOLEAN jjPARSTR1(leftv res, leftv v)
Definition iparith.cc:4840
jjHOMOG1
static BOOLEAN jjHOMOG1(leftv res, leftv v)
Definition iparith.cc:4368
jjDET
static BOOLEAN jjDET(leftv res, leftv v)
Definition iparith.cc:4096
jjCOUNT_M
static BOOLEAN jjCOUNT_M(leftv res, leftv v)
Definition iparith.cc:4006
jjRING_LIST
static BOOLEAN jjRING_LIST(leftv res, leftv v)
Definition iparith.cc:5007
jjVARSTR1
static BOOLEAN jjVARSTR1(leftv res, leftv v)
Definition iparith.cc:5497
jjSYZYGY
static BOOLEAN jjSYZYGY(leftv res, leftv v)
Definition iparith.cc:5224
jjLU_DECOMP
static BOOLEAN jjLU_DECOMP(leftv res, leftv v)
Definition iparith.cc:4666
jjNVARS
static BOOLEAN jjNVARS(leftv res, leftv v)
Definition iparith.cc:4801
jjERROR
static BOOLEAN jjERROR(leftv, leftv u)
Definition iparith.cc:1999
jjRINGLIST_C
static BOOLEAN jjRINGLIST_C(leftv res, leftv v)
Definition iparith.cc:5000
jjPRINT
BOOLEAN jjPRINT(leftv res, leftv u)
Definition ipprint.cc:252
jjVARIABLES_P
BOOLEAN jjVARIABLES_P(leftv res, leftv u)
Definition ipshell.cc:6310
jjMINRES
BOOLEAN jjMINRES(leftv res, leftv v)
Definition ipshell.cc:954
syBetti1
BOOLEAN syBetti1(leftv res, leftv u)
Definition ipshell.cc:3166
jjCHARSERIES
BOOLEAN jjCHARSERIES(leftv res, leftv u)
Definition ipshell.cc:3349
mpJacobi
BOOLEAN mpJacobi(leftv res, leftv a)
Definition ipshell.cc:3064
kWeight
BOOLEAN kWeight(leftv res, leftv id)
Definition ipshell.cc:3297
kQHWeight
BOOLEAN kQHWeight(leftv res, leftv v)
Definition ipshell.cc:3325
jjBETTI
BOOLEAN jjBETTI(leftv res, leftv u)
Definition ipshell.cc:975
jjVARIABLES_ID
BOOLEAN jjVARIABLES_ID(leftv res, leftv u)
Definition ipshell.cc:6318
loNewtonP
BOOLEAN loNewtonP(leftv res, leftv arg1)
compute Newton Polytopes of input polynomials
Definition ipshell.cc:4566
jjR2_CR
BOOLEAN jjR2_CR(leftv res, leftv a)
Definition number2.cc:132
ERROR_CMD
@ ERROR_CMD
Definition tok.h:72
PFAC_CMD
@ PFAC_CMD
Definition tok.h:154
PARSTR_CMD
@ PARSTR_CMD
Definition tok.h:153
HIGHCORNER_CMD
@ HIGHCORNER_CMD
Definition tok.h:88
REPART_CMD
@ REPART_CMD
Definition tok.h:168
VARIABLES_CMD
@ VARIABLES_CMD
Definition tok.h:201
JACOB_CMD
@ JACOB_CMD
Definition tok.h:103
MSTD_CMD
@ MSTD_CMD
Definition tok.h:133
INDEPSET_CMD
@ INDEPSET_CMD
Definition tok.h:94
RESTART_CMD
@ RESTART_CMD
Definition tok.h:172
BAREISS_CMD
@ BAREISS_CMD
Definition tok.h:37
DEG_CMD
@ DEG_CMD
Definition tok.h:60
READ_CMD
@ READ_CMD
Definition tok.h:165
CLOSE_CMD
@ CLOSE_CMD
Definition tok.h:49
SLIM_GB_CMD
@ SLIM_GB_CMD
Definition tok.h:181
COUNT_CMD
@ COUNT_CMD
Definition tok.h:55
MULTIPLICITY_CMD
@ MULTIPLICITY_CMD
Definition tok.h:134
NAMES_CMD
@ NAMES_CMD
Definition tok.h:136
HILBERT_CMD
@ HILBERT_CMD
Definition tok.h:89
RIGHTSTD_CMD
@ RIGHTSTD_CMD
Definition tok.h:174
HOMOG_CMD
@ HOMOG_CMD
Definition tok.h:90
NVARS_CMD
@ NVARS_CMD
Definition tok.h:143
MEMORY_CMD
@ MEMORY_CMD
Definition tok.h:124
NEWTONPOLY_CMD
@ NEWTONPOLY_CMD
Definition tok.h:140
KBASE_CMD
@ KBASE_CMD
Definition tok.h:106
ATTRIB_CMD
@ ATTRIB_CMD
Definition tok.h:36
CHARSTR_CMD
@ CHARSTR_CMD
Definition tok.h:43
JANET_CMD
@ JANET_CMD
Definition tok.h:104
OPTION_CMD
@ OPTION_CMD
Definition tok.h:148
OPEN_CMD
@ OPEN_CMD
Definition tok.h:145
COEFFS_CMD
@ COEFFS_CMD
Definition tok.h:50
LEADEXP_CMD
@ LEADEXP_CMD
Definition tok.h:113
CNUMBER_CMD
@ CNUMBER_CMD
Definition tok.h:47
TRANSPOSE_CMD
@ TRANSPOSE_CMD
Definition tok.h:193
STD_CMD
@ STD_CMD
Definition tok.h:186
SBA_CMD
@ SBA_CMD
Definition tok.h:178
WAITALL_CMD
@ WAITALL_CMD
Definition tok.h:205
EXECUTE_CMD
@ EXECUTE_CMD
Definition tok.h:73
DET_CMD
@ DET_CMD
Definition tok.h:64
RING_LIST_CMD
@ RING_LIST_CMD
Definition tok.h:176
NUMERATOR_CMD
@ NUMERATOR_CMD
Definition tok.h:142
ORD_CMD
@ ORD_CMD
Definition tok.h:144
PRINT_CMD
@ PRINT_CMD
Definition tok.h:156
UNIVARIATE_CMD
@ UNIVARIATE_CMD
Definition tok.h:197
PARDEG_CMD
@ PARDEG_CMD
Definition tok.h:151
NPARS_CMD
@ NPARS_CMD
Definition tok.h:141
PARENT_CMD
@ PARENT_CMD
Definition tok.h:152
PRIME_CMD
@ PRIME_CMD
Definition tok.h:155
LEADCOEF_CMD
@ LEADCOEF_CMD
Definition tok.h:112
IMPART_CMD
@ IMPART_CMD
Definition tok.h:92
NAMEOF_CMD
@ NAMEOF_CMD
Definition tok.h:135
TYPEOF_CMD
@ TYPEOF_CMD
Definition tok.h:196
KILLATTR_CMD
@ KILLATTR_CMD
Definition tok.h:108
REGULARITY_CMD
@ REGULARITY_CMD
Definition tok.h:167
WAIT1ST_CMD
@ WAIT1ST_CMD
Definition tok.h:204
CONTENT_CMD
@ CONTENT_CMD
Definition tok.h:53
DEGREE_CMD
@ DEGREE_CMD
Definition tok.h:61
OPPOSITE_CMD
@ OPPOSITE_CMD
Definition tok.h:147
GETDUMP_CMD
@ GETDUMP_CMD
Definition tok.h:87
WEIGHT_CMD
@ WEIGHT_CMD
Definition tok.h:207
MONITOR_CMD
@ MONITOR_CMD
Definition tok.h:129
VARSTR_CMD
@ VARSTR_CMD
Definition tok.h:202
PRUNE_CMD
@ PRUNE_CMD
Definition tok.h:157
DUMP_CMD
@ DUMP_CMD
Definition tok.h:68
ENVELOPE_CMD
@ ENVELOPE_CMD
Definition tok.h:71
INTERRED_CMD
@ INTERRED_CMD
Definition tok.h:99
SQR_FREE_CMD
@ SQR_FREE_CMD
Definition tok.h:183
SORTVEC_CMD
@ SORTVEC_CMD
Definition tok.h:182
FACSTD_CMD
@ FACSTD_CMD
Definition tok.h:79
QHWEIGHT_CMD
@ QHWEIGHT_CMD
Definition tok.h:159
RINGLIST_CMD
@ RINGLIST_CMD
Definition tok.h:175
LEAD_CMD
@ LEAD_CMD
Definition tok.h:111
ORDSTR_CMD
@ ORDSTR_CMD
Definition tok.h:149
LOAD_CMD
@ LOAD_CMD
Definition tok.h:119
DENOMINATOR_CMD
@ DENOMINATOR_CMD
Definition tok.h:63
TWOSTD_CMD
@ TWOSTD_CMD
Definition tok.h:195
FINDUNI_CMD
@ FINDUNI_CMD
Definition tok.h:85
CPOLY_CMD
@ CPOLY_CMD
Definition tok.h:48
TRACE_CMD
@ TRACE_CMD
Definition tok.h:194
KERNEL_CMD
@ KERNEL_CMD
Definition tok.h:107
VDIM_CMD
@ VDIM_CMD
Definition tok.h:203
MINBASE_CMD
@ MINBASE_CMD
Definition tok.h:125
SYZYGY_CMD
@ SYZYGY_CMD
Definition tok.h:190
LEADMONOM_CMD
@ LEADMONOM_CMD
Definition tok.h:114
DIM_CMD
@ DIM_CMD
Definition tok.h:66
ROWS_CMD
@ ROWS_CMD
Definition tok.h:177
RESERVEDNAME_CMD
@ RESERVEDNAME_CMD
Definition tok.h:170
DEFINED_CMD
@ DEFINED_CMD
Definition tok.h:59
IS_RINGVAR
@ IS_RINGVAR
Definition tok.h:102
CHARACTERISTIC_CMD
@ CHARACTERISTIC_CMD
Definition tok.h:42
LU_CMD
@ LU_CMD
Definition tok.h:121
COLS_CMD
@ COLS_CMD
Definition tok.h:52
FAC_CMD
@ FAC_CMD
Definition tok.h:76
MINRES_CMD
@ MINRES_CMD
Definition tok.h:127
LAGSOLVE_CMD
@ LAGSOLVE_CMD
Definition tok.h:110
CHAR_SERIES_CMD
@ CHAR_SERIES_CMD
Definition tok.h:44
RANK_CMD
@ RANK_CMD
Definition tok.h:164

## dArith2

const struct sValCmd2 dArith2[]

extern

Definition at line 325 of file table.h.

{
// operations:
// proc cmd res arg1 arg2 context
{D(jjCOLCOL), COLONCOLON, ANY_TYPE, DEF_CMD, DEF_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_I), '+', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_BI), '+', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_N), '+', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_B), '+', BUCKET_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_V), '+', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_ID), '+', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_ID), '+', MODUL_CMD, MODUL_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_P_MA), '+', MATRIX_CMD, POLY_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_MA_P), '+', MATRIX_CMD, MATRIX_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_MA), '+', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_SM), '+', SMATRIX_CMD, SMATRIX_CMD,SMATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_S), '+', STRING_CMD, STRING_CMD, STRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_BIM), '+', BIGINTMAT_CMD, BIGINTMAT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_BIM), '+', BIGINTVEC_CMD, BIGINTVEC_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_I), '+', BIGINTMAT_CMD, BIGINTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_BIM), '+', BIGINTMAT_CMD, INT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_BI), '+', BIGINTMAT_CMD, BIGINTMAT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BI_BIM), '+', BIGINTMAT_CMD, BIGINT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_I), '+', BIGINTVEC_CMD, BIGINTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_BIM), '+', BIGINTVEC_CMD, INT_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_BI), '+', BIGINTVEC_CMD, BIGINTVEC_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BI_BIM), '+', BIGINTVEC_CMD, BIGINT_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), '+', INTVEC_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_IV), '+', INTVEC_CMD, INT_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IM_I), '+', INTMAT_CMD, INTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_IM), '+', INTMAT_CMD, INT_CMD, INTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_IV), '+', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_IV), '+', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, ALLOW_NC | ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2_OP2),'+', CNUMBER_CMD, CNUMBER_CMD,CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'+', CNUMBER_CMD, DEF_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'+', CNUMBER_CMD, CNUMBER_CMD,DEF_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_OP2), '+', CPOLY_CMD, CPOLY_CMD, DEF_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_OP2), '+', CPOLY_CMD, DEF_CMD, CPOLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_BIM), '+', CMATRIX_CMD, CMATRIX_CMD, CMATRIX_CMD, ALLOW_NC | ALLOW_RING}
#endif
,{D(lAdd), '+', LIST_CMD, LIST_CMD, LIST_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjRSUM), '+', RING_CMD, RING_CMD, RING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjRPLUS), '+', RING_CMD, RING_CMD, STRING_CMD, ALLOW_LP | ALLOW_RING}
,{D(jjRPLUS), '+', RING_CMD, STRING_CMD, RING_CMD, ALLOW_LP | ALLOW_RING}
,{D(jjPLUS_B_P), '+', BUCKET_CMD, BUCKET_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_I), '-', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_BI), '-', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_N), '-', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_B), '-', BUCKET_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_V), '-', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_V), '-', VECTOR_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPLUS_MA_P), '-', MATRIX_CMD, MATRIX_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_MA), '-', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_SM), '-', SMATRIX_CMD, SMATRIX_CMD,SMATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_BIM), '-', BIGINTMAT_CMD, BIGINTMAT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_I), '-', BIGINTMAT_CMD, BIGINTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_BIM), '-', BIGINTMAT_CMD, INT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_BI), '-', BIGINTMAT_CMD, BIGINTMAT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BI_BIM), '-', BIGINTMAT_CMD, BIGINT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_BIM), '-', BIGINTVEC_CMD, BIGINTVEC_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_I), '-', BIGINTVEC_CMD, BIGINTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_BIM), '-', BIGINTVEC_CMD, INT_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_BI), '-', BIGINTVEC_CMD, BIGINTVEC_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BI_BIM), '-', BIGINTVEC_CMD, BIGINT_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), '-', INTVEC_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IM_I), '-', INTMAT_CMD, INTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_IV), '-', INTVEC_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_IV), '-', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, ALLOW_NC | ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2_OP2),'-', CNUMBER_CMD, CNUMBER_CMD,CNUMBER_CMD, ALLOW_NALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'-', CNUMBER_CMD, INT_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'-', CNUMBER_CMD, CNUMBER_CMD,INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'-', CNUMBER_CMD, BIGINT_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'-', CNUMBER_CMD, CNUMBER_CMD,BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_OP2), '-', CPOLY_CMD, CPOLY_CMD, CPOLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_OP2), '-', CPOLY_CMD, CPOLY_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_OP2), '-', CPOLY_CMD, INT_CMD, CPOLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMINUS_BIM), '-', CMATRIX_CMD, CMATRIX_CMD,CMATRIX_CMD, ALLOW_NC | ALLOW_RING}
#endif
,{D(jjRMINUS), '-', RING_CMD, RING_CMD, STRING_CMD, ALLOW_LP | ALLOW_RING}
,{D(jjMINUS_B_P), '-', BUCKET_CMD, BUCKET_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , '-', NONE, IDEAL_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , '-', NONE, MODUL_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_I), '*', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_BI), '*', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_N), '*', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_P), '*', POLY_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_P), '*', VECTOR_CMD, POLY_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_P), '*', VECTOR_CMD, VECTOR_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_P1),'*', IDEAL_CMD, IDEAL_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_P2),'*', IDEAL_CMD, POLY_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_P1),'*', MODUL_CMD, MODUL_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_P2),'*', MODUL_CMD, POLY_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_ID), '*', IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_P1),'*', MODUL_CMD, IDEAL_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_P2),'*', MODUL_CMD, VECTOR_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_ID), '*', MODUL_CMD, IDEAL_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_ID), '*', MODUL_CMD, MODUL_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_P1),'*', MATRIX_CMD, MATRIX_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_P2),'*', MATRIX_CMD, POLY_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_N1),'*', MATRIX_CMD, MATRIX_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_N2),'*', MATRIX_CMD, NUMBER_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_I1),'*', MATRIX_CMD, MATRIX_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_I2),'*', MATRIX_CMD, INT_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA), '*', MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_BI1),'*', MATRIX_CMD, MATRIX_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_MA_BI2),'*', MATRIX_CMD, BIGINT_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_SM), '*', SMATRIX_CMD, SMATRIX_CMD,SMATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_BIM), '*', BIGINTMAT_CMD, BIGINTMAT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_I), '*', BIGINTMAT_CMD, BIGINTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_BIM), '*', BIGINTMAT_CMD, INT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_BI), '*', BIGINTMAT_CMD, BIGINTMAT_CMD, BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
,{D(jjOP_BI_BIM), '*', BIGINTMAT_CMD, BIGINT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_I), '*', BIGINTVEC_CMD, BIGINTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_BIM), '*', BIGINTVEC_CMD, INT_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_BIM_BI), '*', BIGINTVEC_CMD, BIGINTVEC_CMD, BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
,{D(jjOP_BI_BIM), '*', BIGINTVEC_CMD, BIGINT_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), '*', INTVEC_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_IV), '*', INTVEC_CMD, INT_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), '*', INTMAT_CMD, INTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_I_IV), '*', INTMAT_CMD, INT_CMD, INTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_IV), '*', INTVEC_CMD, INTMAT_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_IV), '*', INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_IV), '*', INTMAT_CMD, INTVEC_CMD, INTMAT_CMD, ALLOW_NC | ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2_OP2),'*', CNUMBER_CMD, CNUMBER_CMD,CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'*', CNUMBER_CMD, INT_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'*', CNUMBER_CMD, CNUMBER_CMD,INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'*', CNUMBER_CMD, BIGINT_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'*', CNUMBER_CMD, CNUMBER_CMD,BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_OP2), '*', CPOLY_CMD, CPOLY_CMD, CPOLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_OP2), '*', CPOLY_CMD, CPOLY_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_OP2), '*', CPOLY_CMD, INT_CMD, CPOLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjTIMES_BIM), '*', CMATRIX_CMD, CMATRIX_CMD, CMATRIX_CMD, ALLOW_NC | ALLOW_RING}
#endif
,{ jjWRONG2, '*', 0, MODUL_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING|NO_CONVERSION}
,{D(jjDIV_N), '/', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjDIV_P), '/', POLY_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjDIV_P), '/', VECTOR_CMD, VECTOR_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjDIV_Ma), '/', MATRIX_CMD, MATRIX_CMD, POLY_CMD, ALLOW_PLURAL | NO_RING}
,{D(jjDIVMOD_I), '/', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjDIV_BI), '/', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), '/', INTVEC_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), '/', INTMAT_CMD, INTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCRING_Zp), '/', CRING_CMD, CRING_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
,{D(jjCRING_Zm), '/', CRING_CMD, CRING_CMD, BIGINT_CMD, ALLOW_PLURAL | ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2_OP2),'/', CNUMBER_CMD, CNUMBER_CMD,CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'/', CNUMBER_CMD, INT_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'/', CNUMBER_CMD, CNUMBER_CMD,INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'/', CNUMBER_CMD, BIGINT_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'/', CNUMBER_CMD, CNUMBER_CMD,BIGINT_CMD, ALLOW_NC | ALLOW_RING}
#endif
,{D(jjDIVMOD_I), INTDIV_CMD, INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjDIV_BI), INTDIV_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), INTDIV_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), INTDIV_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjDIV_P), INTDIV_CMD, POLY_CMD, POLY_CMD, POLY_CMD, ALLOW_PLURAL | ALLOW_RING}
,{D(jjDIV_P), INTDIV_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, ALLOW_PLURAL | ALLOW_RING}
,{D(jjDIVMOD_I), '%', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMOD_BI), '%', BIGINT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), '%', INTVEC_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOP_IV_I), '%', INTMAT_CMD, INTMAT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMOD_N), '%', NUMBER_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMOD_P), '%', POLY_CMD, POLY_CMD, POLY_CMD, NO_NC | NO_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2_OP2),'%', CNUMBER_CMD, CNUMBER_CMD,CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'%', CNUMBER_CMD, INT_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'%', CNUMBER_CMD, CNUMBER_CMD,INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'%', CNUMBER_CMD, BIGINT_CMD, CNUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjNUMBER2_OP2),'%', CNUMBER_CMD, CNUMBER_CMD,BIGINT_CMD, ALLOW_NC | ALLOW_RING}
#endif
,{D(jjPOWER_I), '^', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOWER_BI), '^', BIGINT_CMD, BIGINT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOWER_N), '^', NUMBER_CMD, NUMBER_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOWER_P), '^', POLY_CMD, POLY_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOWER_ID), '^', IDEAL_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2_POW),'^', CNUMBER_CMD, CNUMBER_CMD,INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjPOLY2_POW), '^', CPOLY_CMD, CPOLY_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
#endif
,{D(jjLE_I), LE, INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjLE_BI), LE, INT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjLE_N), LE, INT_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_S), LE, INT_CMD, STRING_CMD, STRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV_I),LE, INT_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV),LE, INT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_P), LE, INT_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_P), LE, INT_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_MA),LE, INT_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING | NO_CONVERSION }
,{D(jjLT_I), '<', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjLT_BI), '<', INT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjLT_N), '<', INT_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV_I),'<', INT_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV),'<', INT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_S), '<', INT_CMD, STRING_CMD, STRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_P), '<', INT_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_P), '<', INT_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_MA),'<', INT_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING | NO_CONVERSION }
,{D(jjGE_I), GE, INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjGE_BI), GE, INT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjGE_N), GE, INT_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_S), GE, INT_CMD, STRING_CMD, STRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV_I),GE, INT_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV),GE, INT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_P), GE, INT_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_P), GE, INT_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_MA),GE, INT_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING | NO_CONVERSION }
,{D(jjGT_I), '>', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjGT_BI), '>', INT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjGT_N), '>', INT_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_S), '>', INT_CMD, STRING_CMD, STRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV_I),'>', INT_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV),'>', INT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_P), '>', INT_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_P), '>', INT_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_MA),'>', INT_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING | NO_CONVERSION }
,{D(jjAND_I), '&', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjOR_I), '|', INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_I), EQUAL_EQUAL, INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_I), EQUAL_EQUAL, INT_CMD, RING_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_I), EQUAL_EQUAL, INT_CMD, RING_CMD, RING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_BI), EQUAL_EQUAL, INT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_N), EQUAL_EQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_S), EQUAL_EQUAL, INT_CMD, STRING_CMD, STRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_P), EQUAL_EQUAL, INT_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_P), EQUAL_EQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV_I),EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV),EQUAL_EQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV),EQUAL_EQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_BIM),EQUAL_EQUAL, INT_CMD, BIGINTMAT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_BIM),EQUAL_EQUAL, INT_CMD, BIGINTVEC_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjCOMPARE_BIM),EQUAL_EQUAL, INT_CMD, CMATRIX_CMD, CMATRIX_CMD, ALLOW_NC | ALLOW_RING}
#endif
,{D(jjEQUAL_CR), EQUAL_EQUAL, INT_CMD, CRING_CMD, CRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_Ma), EQUAL_EQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_SM), EQUAL_EQUAL, INT_CMD, SMATRIX_CMD,SMATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_R), EQUAL_EQUAL, INT_CMD, RING_CMD, RING_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , EQUAL_EQUAL, 0, IDEAL_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , EQUAL_EQUAL, 0, MODUL_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , EQUAL_EQUAL, 0, IDEAL_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , EQUAL_EQUAL, 0, MODUL_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_I), NOTEQUAL, INT_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_BI), NOTEQUAL, INT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_N), NOTEQUAL, INT_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_S), NOTEQUAL, INT_CMD, STRING_CMD, STRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_P), NOTEQUAL, INT_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_P), NOTEQUAL, INT_CMD, VECTOR_CMD, VECTOR_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV),NOTEQUAL, INT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_IV),NOTEQUAL, INT_CMD, INTMAT_CMD, INTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_Ma), NOTEQUAL, INT_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_SM), NOTEQUAL, INT_CMD, SMATRIX_CMD,SMATRIX_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_BIM),NOTEQUAL, INT_CMD, BIGINTMAT_CMD, BIGINTMAT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOMPARE_BIM),NOTEQUAL, INT_CMD, BIGINTVEC_CMD, BIGINTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_CR), NOTEQUAL, INT_CMD, CRING_CMD, CRING_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , NOTEQUAL, 0, IDEAL_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , NOTEQUAL, 0, MODUL_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , NOTEQUAL, 0, IDEAL_CMD, MODUL_CMD, ALLOW_NC | ALLOW_RING}
,{ jjWRONG2 , NOTEQUAL, 0, MODUL_CMD, IDEAL_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjEQUAL_R), NOTEQUAL, INT_CMD, RING_CMD, RING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjDOTDOT), DOTDOT, INTVEC_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_I), '[', INT_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_IV), '[', INT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_I), '[', BIGINT_CMD, BIGINTVEC_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_IV), '[', BIGINT_CMD, BIGINTVEC_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_I), '[', POLY_CMD, IDEAL_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_I), '[', POLY_CMD, MAP_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_IV), '[', POLY_CMD, IDEAL_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_I), '[', VECTOR_CMD, MODUL_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_IV), '[', VECTOR_CMD, MODUL_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_I), '[', STRING_CMD, STRING_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_IV), '[', STRING_CMD, STRING_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_I), '[', ANY_TYPE/*set by p*/,LIST_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_IV), '[', ANY_TYPE/*set by p*/,LIST_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_P), '[', POLY_CMD, POLY_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_PBu), '[', POLY_CMD, BUCKET_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_P_IV),'[', POLY_CMD, POLY_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_V), '[', POLY_CMD, VECTOR_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjINDEX_V_IV),'[', VECTOR_CMD, VECTOR_CMD, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjRING_1), '[', RING_CMD, CRING_CMD, ANY_TYPE, ALLOW_NC | ALLOW_RING}
,{D(jjPROC), '(', ANY_TYPE/*set by p*/,PROC_CMD, DEF_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjMAP), '(', ANY_TYPE/*set by p*/,MAP_CMD, DEF_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjLOAD2), '(', NONE, LIB_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjKLAMMER), '(', ANY_TYPE/*set by p*/,ANY_TYPE, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjKLAMMER_IV),'(', ANY_TYPE/*set by p*/,ANY_TYPE, INTVEC_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjCOLON), ':', INTVEC_CMD, INT_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
// and the procedures with 2 arguments:
,{D(jjALIGN_V), ALIGN_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjALIGN_M), ALIGN_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
,{D(atATTRIB2), ATTRIB_CMD, NONE/*set by p*/,DEF_CMD, STRING_CMD, ALLOW_NC | ALLOW_RING}
,{D(jjBETTI2), BETTI_CMD, INTMAT_CMD, LIST_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
,{D(syBetti2), BETTI_CMD, INTMAT_CMD, RESOLUTION_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
,{D(jjBETTI2_ID), BETTI_CMD, INTMAT_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
,{D(jjBETTI2_ID), BETTI_CMD, INTMAT_CMD, MODUL_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING}
#if defined(HAVE_PLURAL) || defined(HAVE_SHIFTBBA)
,{D(jjBRACKET), BRACKET_CMD, POLY_CMD, POLY_CMD, POLY_CMD, ALLOW_NC | ALLOW_RING}
#endif
,{D(jjCHINREM_BI),CHINREM_CMD, BIGINT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
//,{D(jjCHINREM_P), CHINREM_CMD, POLY_CMD, LIST_CMD, INTVEC_CMD, ALLOW_PLURAL}
,{D(jjCHINREM_ID),CHINREM_CMD, ANY_TYPE/*set by p*/,LIST_CMD,INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjCHINREM_ID),CHINREM_CMD, ANY_TYPE/*set by p*/,LIST_CMD,LIST_CMD, ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2CR), CNUMBER_CMD, CNUMBER_CMD, INT_CMD, CRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjNUMBER2CR), CNUMBER_CMD, CNUMBER_CMD, BIGINT_CMD, CRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjNUMBER2CR), CNUMBER_CMD, CNUMBER_CMD, NUMBER_CMD, CRING_CMD, ALLOW_NC |ALLOW_RING}
#endif
,{D(jjCOEF), COEF_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjCOEF_Id), COEF_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjCOEFFS_Id), COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjCOEFFS_Id), COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjCOEFFS2_KB),COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjCOEFFS2_KB),COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjCONTRACT), CONTRACT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDEG_IV), DEG_CMD, INT_CMD, POLY_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjDEG_IV), DEG_CMD, INT_CMD, VECTOR_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjDEG_M_IV), DEG_CMD, INT_CMD, MATRIX_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjDelete_IV), DELETE_CMD, INTVEC_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjDelete_ID), DELETE_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjDelete_ID_IV),DELETE_CMD, IDEAL_CMD, IDEAL_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjDelete_ID), DELETE_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjDelete_ID_IV),DELETE_CMD, MODUL_CMD, MODUL_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(lDelete), DELETE_CMD, LIST_CMD, LIST_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(lDeleteIV), DELETE_CMD, LIST_CMD, LIST_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjDET2_S), DET_CMD, POLY_CMD, SMATRIX_CMD,STRING_CMD, NO_NC |NO_RING}
,{D(jjDET2), DET_CMD, POLY_CMD, MATRIX_CMD, STRING_CMD, NO_NC |ALLOW_RING}
,{D(jjDIFF_P), DIFF_CMD, POLY_CMD, POLY_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIFF_P), DIFF_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIFF_ID), DIFF_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIFF_ID_ID),DIFF_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIFF_ID), DIFF_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIFF_ID), DIFF_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIFF_COEF), DIFF_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIM2), DIM_CMD, INT_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIM2), DIM_CMD, INT_CMD, MODUL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIVISION), DIVISION_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIVISION), DIVISION_CMD, LIST_CMD, MODUL_CMD, MODUL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjELIMIN), ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjELIMIN), ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjELIMIN_IV), ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjELIMIN_IV), ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjEXPORTTO), EXPORTTO_CMD, NONE, PACKAGE_CMD, IDHDL, ALLOW_NC |ALLOW_RING}
,{D(jjEXTGCD_I), EXTGCD_CMD, LIST_CMD, INT_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjEXTGCD_BI), EXTGCD_CMD, LIST_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjEXTGCD_P), EXTGCD_CMD, LIST_CMD, POLY_CMD, POLY_CMD, NO_NC |NO_RING}
,{D(jjFAC_P2), FAC_CMD, IDEAL_CMD, POLY_CMD, INT_CMD, NO_NC |NO_RING}
,{D(jjFACSTD2), FACSTD_CMD, LIST_CMD, IDEAL_CMD, IDEAL_CMD, NO_NC |NO_RING}
,{D(jjFAREY_BI), FAREY_CMD, NUMBER_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjFAREY_ID), FAREY_CMD, IDEAL_CMD, IDEAL_CMD, BIGINT_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjFAREY_ID), FAREY_CMD, MODUL_CMD, MODUL_CMD, BIGINT_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjFAREY_ID), FAREY_CMD, MATRIX_CMD, MATRIX_CMD, BIGINT_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjFAREY_ID), FAREY_CMD, SMATRIX_CMD, SMATRIX_CMD, BIGINT_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjFAREY_LI), FAREY_CMD, LIST_CMD, LIST_CMD, BIGINT_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjFETCH), FETCH_CMD, ANY_TYPE/*set by p*/,RING_CMD, ANY_TYPE, ALLOW_NC |ALLOW_RING}
,{D(fglmProc), FGLM_CMD, IDEAL_CMD, RING_CMD, DEF_CMD, NO_NC |NO_RING}
,{D(fglmQuotProc),FGLMQUOT_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, NO_NC |NO_RING}
,{D(jjFIND2), FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjFRES), FRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD, NO_NC |NO_RING}
,{D(jjFRES), FRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD, NO_NC |NO_RING}
,{D(jjFWALK), FWALK_CMD, IDEAL_CMD, RING_CMD, DEF_CMD, NO_NC |NO_RING}
,{D(jjGCD_I), GCD_CMD, INT_CMD, INT_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjGCD_N), GCD_CMD, NUMBER_CMD, NUMBER_CMD, NUMBER_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjGCD_BI), GCD_CMD, BIGINT_CMD, BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjGCD_P), GCD_CMD, POLY_CMD, POLY_CMD, POLY_CMD, NO_NC |ALLOW_RING}
,{D(jjHILBERT2), HILBERT_CMD, BIGINTVEC_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHILBERT2), HILBERT_CMD, BIGINTVEC_CMD, MODUL_CMD, INT_CMD, ALLOW_PLURAL | ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHOMOG1_WI), HOMOG_CMD, INT_CMD, IDEAL_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG1_W), HOMOG_CMD, INT_CMD, MODUL_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG_P), HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG_P), HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG_ID), HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG_ID), HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjRES), HRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD, NO_NC |NO_RING}
,{D(jjFETCH), IMAP_CMD, ANY_TYPE/*set by p*/,RING_CMD, ANY_TYPE, ALLOW_NC |ALLOW_RING}
,{D(jjIMPORTFROM),IMPORTFROM_CMD, NONE, PACKAGE_CMD, ANY_TYPE, ALLOW_NC |ALLOW_RING}
,{D(jjINDEPSET2), INDEPSET_CMD, LIST_CMD, IDEAL_CMD, INT_CMD, NO_NC |NO_RING}
,{D(lInsert), INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjINTERPOLATION),INTERPOLATE_CMD,IDEAL_CMD, LIST_CMD, INTVEC_CMD, NO_NC |NO_RING}
,{D(jjINTERSECT), INTERSECT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjINTERSECT), INTERSECT_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjJanetBasis2), JANET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjJET_P), JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjJET_ID), JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjJET_P), JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjJET_ID), JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjJET_ID), JET_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjKBASE2), KBASE_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING |WARN_RING} /*ring-cf: warning at top level*/
,{D(jjKBASE2), KBASE_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING |WARN_RING} /*ring-cf: warning at top level*/
,{D(jjKERNEL), KERNEL_CMD, IDEAL_CMD, RING_CMD, ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
,{D(atKILLATTR2), KILLATTR_CMD, NONE, IDHDL, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjKoszul), KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD, NO_NC |ALLOW_RING}
,{D(jjKoszul_Id), KOSZUL_CMD, MATRIX_CMD, INT_CMD, IDEAL_CMD, NO_NC |ALLOW_RING}
,{D(jjRES), KRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD, NO_NC |NO_RING}
,{D(jjLIFT), LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLIFT), LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLIFTSTD), LIFTSTD_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLIFTSTD), LIFTSTD_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLOAD_E), LOAD_CMD, NONE, STRING_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjRES), LRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD, NO_NC |NO_RING}
,{D(jjMODULO), MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMODULO), MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMONITOR2), MONITOR_CMD, NONE, LINK_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(nuMPResMat), MPRES_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD, NO_NC |NO_RING}
,{D(jjNEWSTRUCT2),NEWSTRUCT_CMD, NONE, STRING_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
//,{D(jjRES), MRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD, NO_NC |ALLOW_RING}
//,{D(jjRES), MRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD, NO_NC |ALLOW_RING}
,{D(jjRES), MRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjRES), MRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjNUMBER2CR), CNUMBER_CMD, CNUMBER_CMD, INT_CMD, CRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjNUMBER2CR), CNUMBER_CMD, CNUMBER_CMD, BIGINT_CMD, CRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjNUMBER2CR), CNUMBER_CMD, CNUMBER_CMD, NUMBER_CMD, CRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjNUMBER2CR), CNUMBER_CMD, CNUMBER_CMD, CNUMBER_CMD,CRING_CMD, ALLOW_NC |ALLOW_RING}
#endif
,{D(jjPFAC2), PFAC_CMD, LIST_CMD, BIGINT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjPFAC2), PFAC_CMD, LIST_CMD, NUMBER_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
#ifdef HAVE_PLURAL
,{D(jjPlural_num_poly), NCALGEBRA_CMD,NONE, POLY_CMD, POLY_CMD , NO_NC |NO_RING}
,{D(jjPlural_num_mat), NCALGEBRA_CMD,NONE, POLY_CMD, MATRIX_CMD, NO_NC |NO_RING}
,{D(jjPlural_mat_poly), NCALGEBRA_CMD,NONE, MATRIX_CMD, POLY_CMD , NO_NC |NO_RING}
,{D(jjPlural_mat_mat), NCALGEBRA_CMD,NONE, MATRIX_CMD, MATRIX_CMD, NO_NC |NO_RING}
,{D(jjPlural_num_poly), NC_ALGEBRA_CMD,RING_CMD, POLY_CMD, POLY_CMD , NO_NC |NO_RING}
,{D(jjPlural_num_mat), NC_ALGEBRA_CMD,RING_CMD, POLY_CMD, MATRIX_CMD, NO_NC |NO_RING}
,{D(jjPlural_mat_poly), NC_ALGEBRA_CMD,RING_CMD, MATRIX_CMD, POLY_CMD , NO_NC |NO_RING}
,{D(jjPlural_mat_mat), NC_ALGEBRA_CMD,RING_CMD, MATRIX_CMD, MATRIX_CMD, NO_NC |NO_RING}
,{D(jjOPPOSE), OPPOSE_CMD, ANY_TYPE/*set by p*/, RING_CMD, DEF_CMD, ALLOW_PLURAL |NO_RING}
#endif
,{D(jjPARSTR2), PARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjPRINT_FORMAT), PRINT_CMD, STRING_CMD, DEF_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjPRUNE_MAP), PRUNE_MAP_CMD, MODUL_CMD, MODUL_CMD, IDHDL, ALLOW_PLURAL |ALLOW_RING}
,{D(jjQUOT), QUOTIENT_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjQUOT), QUOTIENT_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjQUOT), QUOTIENT_CMD, IDEAL_CMD, MODUL_CMD, MODUL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjRANDOM), RANDOM_CMD, INT_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjRANK2), RANK_CMD, INT_CMD, MATRIX_CMD, INT_CMD, ALLOW_NC |NO_RING}
,{D(jjREAD2), READ_CMD, STRING_CMD, LINK_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE_P), REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE_P), REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE_P), REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE_ID), REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE_ID), REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE_ID), REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjRES), RES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjRES), RES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSBA_1), SBA_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSBA_1), SBA_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSIMPL_P), SIMPLIFY_CMD, POLY_CMD, POLY_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjSIMPL_P), SIMPLIFY_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjSIMPL_ID), SIMPLIFY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjSIMPL_ID), SIMPLIFY_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjSQR_FREE2), SQR_FREE_CMD, IDEAL_CMD, POLY_CMD, INT_CMD, NO_NC |ALLOW_RING}
,{D(jjSTATUS2), STATUS_CMD, STRING_CMD, LINK_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjSTATUS2L), STATUS_CMD, INT_CMD, LIST_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
//,{D(jjRES), SRES_CMD, LIST_CMD, IDEAL_CMD, INT_CMD, NO_NC |ALLOW_RING}
//,{D(jjRES), SRES_CMD, LIST_CMD, MODUL_CMD, INT_CMD, NO_NC |ALLOW_RING}
,{D(jjRES), SRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD, NO_NC |ALLOW_RING}
,{D(jjRES), SRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD, NO_NC |ALLOW_RING}
,{D(jjSTD_1), STD_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSTD_1), STD_CMD, MODUL_CMD, MODUL_CMD, VECTOR_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSTD_1), STD_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSTD_1), STD_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSTD_HILB), STD_CMD, IDEAL_CMD, IDEAL_CMD, BIGINTVEC_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjSTD_HILB), STD_CMD, MODUL_CMD, MODUL_CMD, BIGINTVEC_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjSYZ_2), SYZYGY_CMD, MODUL_CMD, IDEAL_CMD, STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSYZ_2), SYZYGY_CMD, MODUL_CMD, MODUL_CMD, STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjTENSOR_Ma), TENSOR_CMD, MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjTENSOR), TENSOR_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, ALLOW_PLURAL |ALLOW_RING|NO_CONVERSION}
,{D(jjTENSOR), TENSOR_CMD, SMATRIX_CMD, SMATRIX_CMD,SMATRIX_CMD, ALLOW_PLURAL |ALLOW_RING|NO_CONVERSION}
,{D(jjVARSTR2), VARSTR_CMD, STRING_CMD, RING_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjWAIT1ST2), WAIT1ST_CMD, INT_CMD, LIST_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjWAITALL2), WAITALL_CMD, INT_CMD, LIST_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjWEDGE), WEDGE_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD, NO_NC |ALLOW_RING}
,{NULL_VAL, 0, 0, 0, 0, NO_NC |NO_RING}
};
atKILLATTR2
BOOLEAN atKILLATTR2(leftv, leftv a, leftv b)
Definition attrib.cc:493
atATTRIB2
BOOLEAN atATTRIB2(leftv res, leftv v, leftv b)
Definition attrib.cc:282
fglmProc
BOOLEAN fglmProc(leftv result, leftv first, leftv second)
Definition fglm.cc:277
fglmQuotProc
BOOLEAN fglmQuotProc(leftv result, leftv first, leftv second)
Definition fglm.cc:411
jjWRONG2
#define jjWRONG2
Definition gentable.cc:125
BUCKET_CMD
@ BUCKET_CMD
Definition grammar.cc:284
KOSZUL_CMD
@ KOSZUL_CMD
Definition grammar.cc:300
IMAP_CMD
@ IMAP_CMD
Definition grammar.cc:299
LIB_CMD
@ LIB_CMD
Definition grammar.cc:328
FETCH_CMD
@ FETCH_CMD
Definition grammar.cc:296
jjOP_BIM_I
static BOOLEAN jjOP_BIM_I(leftv res, leftv u, leftv v)
Definition iparith.cc:244
jjINDEX_V_IV
static BOOLEAN jjINDEX_V_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1524
jjQUOT
static BOOLEAN jjQUOT(leftv res, leftv u, leftv v)
Definition iparith.cc:3105
jjTIMES_MA_P1
static BOOLEAN jjTIMES_MA_P1(leftv res, leftv u, leftv v)
Definition iparith.cc:1100
jjOP_IV_I
static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
Definition iparith.cc:280
jjEXTGCD_P
static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
Definition iparith.cc:2048
jjDOTDOT
static BOOLEAN jjDOTDOT(leftv res, leftv u, leftv v)
Definition iparith.cc:333
jjTIMES_MA_BI2
static BOOLEAN jjTIMES_MA_BI2(leftv res, leftv u, leftv v)
Definition iparith.cc:1096
jjMAP
static BOOLEAN jjMAP(leftv res, leftv u, leftv v)
Definition iparith.cc:1653
jjGT_BI
static BOOLEAN jjGT_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:1184
jjOP_I_IM
static BOOLEAN jjOP_I_IM(leftv res, leftv u, leftv v)
Definition iparith.cc:316
jjLIFTSTD
static BOOLEAN jjLIFTSTD(leftv res, leftv u, leftv v)
Definition iparith.cc:2609
jjNEWSTRUCT2
static BOOLEAN jjNEWSTRUCT2(leftv, leftv u, leftv v)
Definition iparith.cc:2807
jjMONITOR2
static BOOLEAN jjMONITOR2(leftv res, leftv u, leftv v)
Definition iparith.cc:2742
jjBRACKET
static BOOLEAN jjBRACKET(leftv res, leftv a, leftv b)
Definition iparith.cc:2918
jjHOMOG1_WI
static BOOLEAN jjHOMOG1_WI(leftv res, leftv v, leftv u)
Definition iparith.cc:2507
jjRANDOM
static BOOLEAN jjRANDOM(leftv res, leftv u, leftv v)
Definition iparith.cc:3112
jjDIVISION
static BOOLEAN jjDIVISION(leftv res, leftv u, leftv v)
Definition iparith.cc:1954
jjOP_I_IV
static BOOLEAN jjOP_I_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:297
jjEQUAL_BI
static BOOLEAN jjEQUAL_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:1323
jjMINUS_B_P
static BOOLEAN jjMINUS_B_P(leftv res, leftv u, leftv v)
Definition iparith.cc:909
jjLIFT
static BOOLEAN jjLIFT(leftv res, leftv u, leftv v)
Definition iparith.cc:2589
jjTIMES_MA_N2
static BOOLEAN jjTIMES_MA_N2(leftv res, leftv u, leftv v)
Definition iparith.cc:1125
jjPlural_mat_poly
static BOOLEAN jjPlural_mat_poly(leftv res, leftv a, leftv b)
Definition iparith.cc:2878
jjTIMES_SM
static BOOLEAN jjTIMES_SM(leftv res, leftv u, leftv v)
Definition iparith.cc:1152
jjMOD_BI
static BOOLEAN jjMOD_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:2697
jjTIMES_MA_I2
static BOOLEAN jjTIMES_MA_I2(leftv res, leftv u, leftv v)
Definition iparith.cc:1134
jjSTATUS2L
static BOOLEAN jjSTATUS2L(leftv res, leftv u, leftv v)
Definition iparith.cc:3446
jjGT_I
static BOOLEAN jjGT_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1191
jjPFAC2
static BOOLEAN jjPFAC2(leftv res, leftv u, leftv v)
Definition iparith.cc:3298
jjEQUAL_I
static BOOLEAN jjEQUAL_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1329
jjTIMES_MA_P2
static BOOLEAN jjTIMES_MA_P2(leftv res, leftv u, leftv v)
Definition iparith.cc:1109
jjSBA_1
static BOOLEAN jjSBA_1(leftv res, leftv v, leftv u)
Definition iparith.cc:5109
jjPLUS_MA
static BOOLEAN jjPLUS_MA(leftv res, leftv u, leftv v)
Definition iparith.cc:824
jjMINUS_V
static BOOLEAN jjMINUS_V(leftv res, leftv u, leftv v)
Definition iparith.cc:904
jjTIMES_ID
static BOOLEAN jjTIMES_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:1055
jjLT_N
static BOOLEAN jjLT_N(leftv res, leftv u, leftv v)
Definition iparith.cc:1223
jjMINUS_MA
static BOOLEAN jjMINUS_MA(leftv res, leftv u, leftv v)
Definition iparith.cc:952
jjEXTGCD_I
static BOOLEAN jjEXTGCD_I(leftv res, leftv u, leftv v)
Definition iparith.cc:2020
jjDelete_ID
static BOOLEAN jjDelete_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:1869
jjLE_N
static BOOLEAN jjLE_N(leftv res, leftv u, leftv v)
Definition iparith.cc:1210
jjCOMPARE_S
static BOOLEAN jjCOMPARE_S(leftv res, leftv u, leftv v)
Definition iparith.cc:479
jjOR_I
static BOOLEAN jjOR_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1385
jjTIMES_MA_I1
static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
Definition iparith.cc:1129
jjTIMES_MA_N1
static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
Definition iparith.cc:1118
jjMINUS_BIM
static BOOLEAN jjMINUS_BIM(leftv res, leftv u, leftv v)
Definition iparith.cc:942
jjSQR_FREE2
static BOOLEAN jjSQR_FREE2(leftv res, leftv u, leftv dummy)
Definition iparith.cc:3394
jjMINUS_N
static BOOLEAN jjMINUS_N(leftv res, leftv u, leftv v)
Definition iparith.cc:899
jjDEG_IV
static BOOLEAN jjDEG_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1848
jjMINUS_IV
static BOOLEAN jjMINUS_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:932
jjHOMOG_P
static BOOLEAN jjHOMOG_P(leftv res, leftv u, leftv v)
Definition iparith.cc:2448
jjLE_BI
static BOOLEAN jjLE_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:1201
jjPLUS_B_P
static BOOLEAN jjPLUS_B_P(leftv res, leftv u, leftv v)
Definition iparith.cc:795
jjPlural_mat_mat
static BOOLEAN jjPlural_mat_mat(leftv res, leftv a, leftv b)
Definition iparith.cc:2898
jjPARSTR2
static BOOLEAN jjPARSTR2(leftv res, leftv u, leftv v)
Definition iparith.cc:2821
jjKoszul
static BOOLEAN jjKoszul(leftv res, leftv u, leftv v)
Definition iparith.cc:2577
jjTIMES_N
static BOOLEAN jjTIMES_N(leftv res, leftv u, leftv v)
Definition iparith.cc:998
jjTIMES_MA
static BOOLEAN jjTIMES_MA(leftv res, leftv u, leftv v)
Definition iparith.cc:1138
jjTIMES_IV
static BOOLEAN jjTIMES_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1062
jjPLUS_I
static BOOLEAN jjPLUS_I(leftv res, leftv u, leftv v)
Definition iparith.cc:755
jjREDUCE_ID
static BOOLEAN jjREDUCE_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:3153
jjCOEF
static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
Definition iparith.cc:1793
jjDEG_M_IV
static BOOLEAN jjDEG_M_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1837
jjPLUS_IV
static BOOLEAN jjPLUS_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:804
jjDIFF_COEF
static BOOLEAN jjDIFF_COEF(leftv res, leftv u, leftv v)
Definition iparith.cc:4516
jjGE_N
static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
Definition iparith.cc:1178
jjEQUAL_SM
static BOOLEAN jjEQUAL_SM(leftv res, leftv u, leftv v)
Definition iparith.cc:1341
jjINTERPOLATION
static BOOLEAN jjINTERPOLATION(leftv res, leftv l, leftv v)
Definition iparith.cc:2527
jjSIMPL_ID
static BOOLEAN jjSIMPL_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:3357
jjREDUCE_P
static BOOLEAN jjREDUCE_P(leftv res, leftv u, leftv v)
Definition iparith.cc:3145
jjDIV_Ma
static BOOLEAN jjDIV_Ma(leftv res, leftv u, leftv v)
Definition iparith.cc:1294
jjMODULO
static BOOLEAN jjMODULO(leftv res, leftv u, leftv v)
Definition iparith.cc:2644
jjCOMPARE_IV
static BOOLEAN jjCOMPARE_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:339
jjREAD2
static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
Definition iparith.cc:3129
jjFAREY_ID
static BOOLEAN jjFAREY_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:2145
jjPLUS_ID
static BOOLEAN jjPLUS_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:873
jjGCD_N
static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
Definition iparith.cc:2387
jjELIMIN
static BOOLEAN jjELIMIN(leftv res, leftv u, leftv v)
Definition iparith.cc:1974
jjCHINREM_BI
static BOOLEAN jjCHINREM_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:1682
jjJET_ID
static BOOLEAN jjJET_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:2555
jjOP_IM_I
static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
Definition iparith.cc:301
jjTENSOR
static BOOLEAN jjTENSOR(leftv res, leftv u, leftv v)
Definition iparith.cc:3644
jjFWALK
static BOOLEAN jjFWALK(leftv res, leftv u, leftv v)
Definition iparith.cc:2361
jjDIFF_ID_ID
static BOOLEAN jjDIFF_ID_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:1932
jjSYZ_2
static BOOLEAN jjSYZ_2(leftv res, leftv u, leftv v)
Definition iparith.cc:3572
jjRING_1
static BOOLEAN jjRING_1(leftv res, leftv u, leftv v)
Definition iparith.cc:1673
jjOP_I_BIM
static BOOLEAN jjOP_I_BIM(leftv res, leftv u, leftv v)
Definition iparith.cc:259
jjHILBERT2
static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
Definition iparith.cc:2410
jjFIND2
static BOOLEAN jjFIND2(leftv res, leftv u, leftv v)
Definition iparith.cc:2294
jjCOEF_Id
static BOOLEAN jjCOEF_Id(leftv res, leftv u, leftv v)
Definition iparith.cc:1800
jjPOWER_ID
static BOOLEAN jjPOWER_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:625
jjTIMES_MA_BI1
static BOOLEAN jjTIMES_MA_BI1(leftv res, leftv u, leftv v)
Definition iparith.cc:1086
jjCOEFFS2_KB
static BOOLEAN jjCOEFFS2_KB(leftv res, leftv u, leftv v)
Definition iparith.cc:1818
jjVARSTR2
static BOOLEAN jjVARSTR2(leftv res, leftv u, leftv v)
Definition iparith.cc:3670
jjPLUS_N
static BOOLEAN jjPLUS_N(leftv res, leftv u, leftv v)
Definition iparith.cc:772
jjLT_I
static BOOLEAN jjLT_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1218
jjEXTGCD_BI
static BOOLEAN jjEXTGCD_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:2006
jjGCD_I
static BOOLEAN jjGCD_I(leftv res, leftv u, leftv v)
Definition iparith.cc:2367
jjCONTRACT
static BOOLEAN jjCONTRACT(leftv res, leftv u, leftv v)
Definition iparith.cc:1832
jjFAREY_LI
static BOOLEAN jjFAREY_LI(leftv res, leftv u, leftv v)
Definition iparith.cc:10428
jjDelete_IV
static BOOLEAN jjDelete_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1862
jjGE_BI
static BOOLEAN jjGE_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:1166
jjKERNEL
static BOOLEAN jjKERNEL(leftv res, leftv u, leftv v)
Definition iparith.cc:2573
jjMOD_N
static BOOLEAN jjMOD_N(leftv res, leftv u, leftv v)
Definition iparith.cc:2708
jjLOAD_E
static BOOLEAN jjLOAD_E(leftv, leftv v, leftv u)
Definition iparith.cc:2633
jjEQUAL_R
static BOOLEAN jjEQUAL_R(leftv res, leftv u, leftv v)
Definition iparith.cc:1347
jjINTERSECT
static BOOLEAN jjINTERSECT(leftv res, leftv u, leftv v)
Definition iparith.cc:2521
jjOP_BI_BIM
static BOOLEAN jjOP_BI_BIM(leftv res, leftv u, leftv v)
Definition iparith.cc:276
jjDIFF_P
static BOOLEAN jjDIFF_P(leftv res, leftv u, leftv v)
Definition iparith.cc:1910
jjMINUS_B
static BOOLEAN jjMINUS_B(leftv res, leftv u, leftv v)
Definition iparith.cc:919
jjRSUM
static BOOLEAN jjRSUM(leftv res, leftv u, leftv v)
Definition iparith.cc:3343
jjINDEX_I
static BOOLEAN jjINDEX_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1390
jjPOWER_BI
static BOOLEAN jjPOWER_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:568
jjKLAMMER_IV
static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1572
jjFETCH
static BOOLEAN jjFETCH(leftv res, leftv u, leftv v)
Definition iparith.cc:2166
jjSTD_1
static BOOLEAN jjSTD_1(leftv res, leftv u, leftv v)
Definition iparith.cc:3496
jjTIMES_P
static BOOLEAN jjTIMES_P(leftv res, leftv u, leftv v)
Definition iparith.cc:1008
jjPLUS_SM
static BOOLEAN jjPLUS_SM(leftv res, leftv u, leftv v)
Definition iparith.cc:836
jjMINUS_BI
static BOOLEAN jjMINUS_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:894
jjTIMES_BI
static BOOLEAN jjTIMES_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:991
jjFACSTD2
static BOOLEAN jjFACSTD2(leftv res, leftv v, leftv w)
Definition iparith.cc:2112
jjEXPORTTO
static BOOLEAN jjEXPORTTO(leftv, leftv u, leftv v)
Definition iparith.cc:1994
jjPlural_num_poly
static BOOLEAN jjPlural_num_poly(leftv res, leftv a, leftv b)
Definition iparith.cc:2838
jjDIV_P
static BOOLEAN jjDIV_P(leftv res, leftv u, leftv v)
Definition iparith.cc:1276
jjKBASE2
static BOOLEAN jjKBASE2(leftv res, leftv u, leftv v)
Definition iparith.cc:2560
jjPOWER_I
static BOOLEAN jjPOWER_I(leftv res, leftv u, leftv v)
Definition iparith.cc:522
jjRES
static BOOLEAN jjRES(leftv res, leftv u, leftv v)
Definition iparith.cc:3162
jjPLUS_P_MA
static BOOLEAN jjPLUS_P_MA(leftv res, leftv u, leftv v)
Definition iparith.cc:859
jjPLUS_BIM
static BOOLEAN jjPLUS_BIM(leftv res, leftv u, leftv v)
Definition iparith.cc:814
jjGE_I
static BOOLEAN jjGE_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1173
jjGT_N
static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
Definition iparith.cc:1196
jjWEDGE
static BOOLEAN jjWEDGE(leftv res, leftv u, leftv v)
Definition iparith.cc:3755
jjCOMPARE_P
static BOOLEAN jjCOMPARE_P(leftv res, leftv u, leftv v)
Definition iparith.cc:452
jjPLUS_MA_P
static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
Definition iparith.cc:848
jjSIMPL_P
static BOOLEAN jjSIMPL_P(leftv res, leftv u, leftv v)
Definition iparith.cc:3452
jjELIMIN_IV
static BOOLEAN jjELIMIN_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1980
jjDIFF_ID
static BOOLEAN jjDIFF_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:1921
jjTIMES_BIM
static BOOLEAN jjTIMES_BIM(leftv res, leftv u, leftv v)
Definition iparith.cc:1074
jjTIMES_I
static BOOLEAN jjTIMES_I(leftv res, leftv u, leftv v)
Definition iparith.cc:978
jjDIV_N
static BOOLEAN jjDIV_N(leftv res, leftv u, leftv v)
Definition iparith.cc:1263
jjFRES
static BOOLEAN jjFRES(leftv res, leftv u, leftv v)
Definition iparith.cc:2351
jjKLAMMER
static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
Definition iparith.cc:1560
jjCOMPARE_MA
static BOOLEAN jjCOMPARE_MA(leftv res, leftv u, leftv v)
Definition iparith.cc:424
jjFAREY_BI
static BOOLEAN jjFAREY_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:2134
jjCOMPARE_IV_I
static BOOLEAN jjCOMPARE_IV_I(leftv res, leftv u, leftv v)
Definition iparith.cc:397
jjDIVMOD_I
static BOOLEAN jjDIVMOD_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1227
jjLE_I
static BOOLEAN jjLE_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1205
jjTENSOR_Ma
static BOOLEAN jjTENSOR_Ma(leftv res, leftv u, leftv v)
Definition iparith.cc:3651
jjRMINUS
static BOOLEAN jjRMINUS(leftv res, leftv u, leftv v)
Definition iparith.cc:3324
jjPROC
BOOLEAN jjPROC(leftv res, leftv u, leftv v)
Definition iparith.cc:1617
jjPLUS_BI
static BOOLEAN jjPLUS_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:767
jjDET2
static BOOLEAN jjDET2(leftv res, leftv u, leftv v)
Definition iparith.cc:1896
jjSTD_HILB
static BOOLEAN jjSTD_HILB(leftv res, leftv u, leftv v)
Definition iparith.cc:3468
jjAND_I
static BOOLEAN jjAND_I(leftv res, leftv u, leftv v)
Definition iparith.cc:1380
jjINDEX_P_IV
static BOOLEAN jjINDEX_P_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1488
jjJanetBasis2
static BOOLEAN jjJanetBasis2(leftv res, leftv u, leftv v)
Definition iparith.cc:2539
jjCOLON
static BOOLEAN jjCOLON(leftv res, leftv u, leftv v)
Definition iparith.cc:320
jjRPLUS
static BOOLEAN jjRPLUS(leftv res, leftv u, leftv v)
Definition iparith.cc:3330
jjCOLCOL
static BOOLEAN jjCOLCOL(leftv res, leftv u, leftv v)
Definition iparith.cc:693
jjFAC_P2
static BOOLEAN jjFAC_P2(leftv res, leftv u, leftv dummy)
Definition iparith.cc:2065
jjHOMOG_ID
static BOOLEAN jjHOMOG_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:2465
jjINDEX_V
static BOOLEAN jjINDEX_V(leftv res, leftv u, leftv v)
Definition iparith.cc:1517
jjDIM2
static BOOLEAN jjDIM2(leftv res, leftv v, leftv w)
Definition iparith.cc:1937
jjOP_BIM_BI
static BOOLEAN jjOP_BIM_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:263
jjGCD_BI
static BOOLEAN jjGCD_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:2380
jjRANK2
static BOOLEAN jjRANK2(leftv res, leftv u, leftv v)
Definition iparith.cc:3120
jjINDEPSET2
static BOOLEAN jjINDEPSET2(leftv res, leftv u, leftv v)
Definition iparith.cc:2514
jjWAITALL2
static BOOLEAN jjWAITALL2(leftv res, leftv u, leftv v)
Definition iparith.cc:3707
jjMINUS_SM
static BOOLEAN jjMINUS_SM(leftv res, leftv u, leftv v)
Definition iparith.cc:965
jjINDEX_P
static BOOLEAN jjINDEX_P(leftv res, leftv u, leftv v)
Definition iparith.cc:1448
jjEQUAL_Ma
static BOOLEAN jjEQUAL_Ma(leftv res, leftv u, leftv v)
Definition iparith.cc:1335
jjLOAD2
static BOOLEAN jjLOAD2(leftv, leftv, leftv v)
Definition iparith.cc:2629
jjALIGN_M
static BOOLEAN jjALIGN_M(leftv res, leftv u, leftv v)
Definition iparith.cc:1779
jjWAIT1ST2
static BOOLEAN jjWAIT1ST2(leftv res, leftv u, leftv v)
Definition iparith.cc:3683
jjDIV_BI
static BOOLEAN jjDIV_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:1250
jjCOMPARE_BIM
static BOOLEAN jjCOMPARE_BIM(leftv res, leftv u, leftv v)
Definition iparith.cc:367
jjEQUAL_N
static BOOLEAN jjEQUAL_N(leftv res, leftv u, leftv v)
Definition iparith.cc:1353
jjDelete_ID_IV
static BOOLEAN jjDelete_ID_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1876
jjDET2_S
static BOOLEAN jjDET2_S(leftv res, leftv u, leftv v)
Definition iparith.cc:1903
jjCOEFFS_Id
static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
Definition iparith.cc:1807
jjOPPOSE
static BOOLEAN jjOPPOSE(leftv res, leftv a, leftv b)
Definition iparith.cc:2986
jjMOD_P
static BOOLEAN jjMOD_P(leftv res, leftv u, leftv v)
Definition iparith.cc:2719
jjPLUS_B
static BOOLEAN jjPLUS_B(leftv res, leftv u, leftv v)
Definition iparith.cc:782
jjGCD_P
static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
Definition iparith.cc:2404
jjPLUS_V
static BOOLEAN jjPLUS_V(leftv res, leftv u, leftv v)
Definition iparith.cc:777
jjKoszul_Id
static BOOLEAN jjKoszul_Id(leftv res, leftv u, leftv v)
Definition iparith.cc:2581
jjCHINREM_ID
static BOOLEAN jjCHINREM_ID(leftv res, leftv u, leftv v)
Definition iparith.cc:10229
jjPLUS_S
static BOOLEAN jjPLUS_S(leftv res, leftv u, leftv v)
Definition iparith.cc:863
jjHOMOG1_W
static BOOLEAN jjHOMOG1_W(leftv res, leftv v, leftv u)
Definition iparith.cc:2487
jjINDEX_IV
static BOOLEAN jjINDEX_IV(leftv res, leftv u, leftv v)
Definition iparith.cc:1412
jjMINUS_I
static BOOLEAN jjMINUS_I(leftv res, leftv u, leftv v)
Definition iparith.cc:878
jjJET_P
static BOOLEAN jjJET_P(leftv res, leftv u, leftv v)
Definition iparith.cc:2550
jjPRUNE_MAP
static BOOLEAN jjPRUNE_MAP(leftv res, leftv v, leftv ma)
Definition iparith.cc:3059
jjLT_BI
static BOOLEAN jjLT_BI(leftv res, leftv u, leftv v)
Definition iparith.cc:1214
jjPOWER_P
static BOOLEAN jjPOWER_P(leftv res, leftv u, leftv v)
Definition iparith.cc:602
jjINDEX_PBu
static BOOLEAN jjINDEX_PBu(leftv res, leftv u, leftv v)
Definition iparith.cc:1465
jjPOWER_N
static BOOLEAN jjPOWER_N(leftv res, leftv u, leftv v)
Definition iparith.cc:584
jjEQUAL_P
static BOOLEAN jjEQUAL_P(leftv res, leftv u, leftv v)
Definition iparith.cc:1359
jjPlural_num_mat
static BOOLEAN jjPlural_num_mat(leftv res, leftv a, leftv b)
Definition iparith.cc:2858
jjSTATUS2
static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
Definition iparith.cc:3441
jjALIGN_V
static BOOLEAN jjALIGN_V(leftv res, leftv u, leftv v)
Definition iparith.cc:1769
jjIMPORTFROM
BOOLEAN jjIMPORTFROM(leftv, leftv u, leftv v)
Definition ipassign.cc:2512
jjPRINT_FORMAT
BOOLEAN jjPRINT_FORMAT(leftv res, leftv u, leftv v)
Definition ipprint.cc:391
lDelete
BOOLEAN lDelete(leftv res, leftv u, leftv v)
Definition lists.cc:161
lAdd
BOOLEAN lAdd(leftv res, leftv u, leftv v)
Definition lists.cc:51
lDeleteIV
BOOLEAN lDeleteIV(leftv res, leftv u, leftv v)
Definition lists.cc:192
lInsert
BOOLEAN lInsert(leftv res, leftv u, leftv v)
Definition lists.cc:120
nuMPResMat
BOOLEAN nuMPResMat(leftv res, leftv arg1, leftv arg2)
returns module representing the multipolynomial resultant matrix Arguments 2: ideal i,...
Definition ipshell.cc:4658
jjCRING_Zp
BOOLEAN jjCRING_Zp(leftv res, leftv a, leftv b)
Definition number2.cc:35
jjEQUAL_CR
BOOLEAN jjEQUAL_CR(leftv res, leftv a, leftv b)
Definition number2.cc:123
jjCRING_Zm
BOOLEAN jjCRING_Zm(leftv res, leftv a, leftv b)
Definition number2.cc:88
ELIMINATION_CMD
@ ELIMINATION_CMD
Definition tok.h:69
NCALGEBRA_CMD
@ NCALGEBRA_CMD
Definition tok.h:138
SIMPLIFY_CMD
@ SIMPLIFY_CMD
Definition tok.h:180
FGLMQUOT_CMD
@ FGLMQUOT_CMD
Definition tok.h:84
RANDOM_CMD
@ RANDOM_CMD
Definition tok.h:163
FWALK_CMD
@ FWALK_CMD
Definition tok.h:82
MODULO_CMD
@ MODULO_CMD
Definition tok.h:128
JET_CMD
@ JET_CMD
Definition tok.h:105
DIFF_CMD
@ DIFF_CMD
Definition tok.h:65
LRES_CMD
@ LRES_CMD
Definition tok.h:120
IMPORTFROM_CMD
@ IMPORTFROM_CMD
Definition tok.h:93
HRES_CMD
@ HRES_CMD
Definition tok.h:91
REDUCE_CMD
@ REDUCE_CMD
Definition tok.h:166
LIFTSTD_CMD
@ LIFTSTD_CMD
Definition tok.h:115
KRES_CMD
@ KRES_CMD
Definition tok.h:109
CONTRACT_CMD
@ CONTRACT_CMD
Definition tok.h:54
LIFT_CMD
@ LIFT_CMD
Definition tok.h:116
BRACKET_CMD
@ BRACKET_CMD
Definition tok.h:40
CHINREM_CMD
@ CHINREM_CMD
Definition tok.h:45
NC_ALGEBRA_CMD
@ NC_ALGEBRA_CMD
Definition tok.h:139
MPRES_CMD
@ MPRES_CMD
Definition tok.h:130
MRES_CMD
@ MRES_CMD
Definition tok.h:131
DIVISION_CMD
@ DIVISION_CMD
Definition tok.h:67
EXPORTTO_CMD
@ EXPORTTO_CMD
Definition tok.h:74
PRUNE_MAP_CMD
@ PRUNE_MAP_CMD
Definition tok.h:158
SRES_CMD
@ SRES_CMD
Definition tok.h:184
ALIGN_CMD
@ ALIGN_CMD
Definition tok.h:35
STATUS_CMD
@ STATUS_CMD
Definition tok.h:185
FIND_CMD
@ FIND_CMD
Definition tok.h:78
COEF_CMD
@ COEF_CMD
Definition tok.h:51
WEDGE_CMD
@ WEDGE_CMD
Definition tok.h:206
DELETE_CMD
@ DELETE_CMD
Definition tok.h:62
INTDIV_CMD
@ INTDIV_CMD
Definition tok.h:97
QUOTIENT_CMD
@ QUOTIENT_CMD
Definition tok.h:162
INTERSECT_CMD
@ INTERSECT_CMD
Definition tok.h:100
INSERT_CMD
@ INSERT_CMD
Definition tok.h:95
EXTGCD_CMD
@ EXTGCD_CMD
Definition tok.h:75
GCD_CMD
@ GCD_CMD
Definition tok.h:86
FAREY_CMD
@ FAREY_CMD
Definition tok.h:77
INTERPOLATE_CMD
@ INTERPOLATE_CMD
Definition tok.h:98
NEWSTRUCT_CMD
@ NEWSTRUCT_CMD
Definition tok.h:137
OPPOSE_CMD
@ OPPOSE_CMD
Definition tok.h:146
TENSOR_CMD
@ TENSOR_CMD
Definition tok.h:191
FRES_CMD
@ FRES_CMD
Definition tok.h:81
FGLM_CMD
@ FGLM_CMD
Definition tok.h:83
RES_CMD
@ RES_CMD
Definition tok.h:169

## dArith3

const struct sValCmd3 dArith3[]

extern

Definition at line 801 of file table.h.

{
// operations:
// proc cmd res arg1 arg2 arg3 context
{D(jjBRACK_S), '[', STRING_CMD, STRING_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Im), '[', INT_CMD, INTMAT_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Bim), '[', BIGINT_CMD, BIGINTMAT_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_I_IV), '[', INT_CMD, INTMAT_CMD, INT_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_I_IV), '[', BIGINT_CMD, BIGINTMAT_CMD, INT_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_IV_I), '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_IV_I), '[', BIGINT_CMD, BIGINTMAT_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_IV_IV), '[', INT_CMD, INTMAT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_IV_IV), '[', BIGINT_CMD, BIGINTMAT_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma), '[', POLY_CMD, MATRIX_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_SM), '[', POLY_CMD, SMATRIX_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_I_IV), '[', POLY_CMD, MATRIX_CMD, INT_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_IV_I), '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBRACK_Ma_IV_IV), '[', POLY_CMD, MATRIX_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjRING_2), '[', RING_CMD, CRING_CMD, ANY_TYPE, ANY_TYPE, ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjBRACK_Bim), '[', CNUMBER_CMD, CMATRIX_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
#endif
,{D(jjPROC3), '(', ANY_TYPE, PROC_CMD, DEF_CMD, DEF_CMD, ALLOW_NC |ALLOW_RING}
,{D(atATTRIB3), ATTRIB_CMD, NONE, IDHDL, STRING_CMD, DEF_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjBAREISS3), BAREISS_CMD,LIST_CMD, MODUL_CMD, INT_CMD, INT_CMD, NO_NC |ALLOW_RING|NO_ZERODIVISOR}
#if defined(HAVE_SHIFTBBA) || defined(HAVE_PLURAL)
,{D(jjBRACKET_REC), BRACKET_CMD,POLY_CMD, POLY_CMD, POLY_CMD, INT_CMD, ALLOW_NC | ALLOW_RING}
#endif
,{D(jjCOEFFS3_P), COEFFS_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD, MATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjCOEFFS3_P), COEFFS_CMD, MATRIX_CMD, VECTOR_CMD, POLY_CMD, MATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjCOEFFS3_Id), COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, POLY_CMD, MATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjCOEFFS3_Id), COEFFS_CMD, MATRIX_CMD, MODUL_CMD, POLY_CMD, MATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjCOEFFS3_KB), COEFFS_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjCOEFFS3_KB), COEFFS_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjCMATRIX_3), CMATRIX_CMD, CMATRIX_CMD,INT_CMD, INT_CMD, CRING_CMD, ALLOW_PLURAL |ALLOW_RING}
#endif
,{D(jjELIMIN_HILB), ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, BIGINTVEC_CMD, NO_NC |NO_RING}
,{D(jjELIMIN_HILB), ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD, BIGINTVEC_CMD, NO_NC |NO_RING}
,{D(jjELIMIN_ALG), ELIMINATION_CMD,IDEAL_CMD, IDEAL_CMD, POLY_CMD, STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjELIMIN_ALG), ELIMINATION_CMD,MODUL_CMD, MODUL_CMD, POLY_CMD, STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjFIND3), FIND_CMD, INT_CMD, STRING_CMD, STRING_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjFRES3), FRES_CMD, RESOLUTION_CMD, IDEAL_CMD, INT_CMD, STRING_CMD, NO_NC |NO_RING}
,{D(jjFRES3), FRES_CMD, RESOLUTION_CMD, MODUL_CMD, INT_CMD, STRING_CMD, NO_NC |NO_RING}
,{D(jjFWALK3), FWALK_CMD, IDEAL_CMD, RING_CMD, DEF_CMD, INT_CMD, NO_NC |ALLOW_RING}
,{D(jjHILBERT3), HILBERT_CMD,BIGINTVEC_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD, ALLOW_PLURAL | ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHILBERT3), HILBERT_CMD,BIGINTVEC_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD, ALLOW_PLURAL | ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHILBERT3Qt), HILBERT_CMD,NONE, IDEAL_CMD, RING_CMD, STRING_CMD, ALLOW_PLURAL | ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHILBERT3Qt), HILBERT_CMD,NONE, MODUL_CMD, RING_CMD, STRING_CMD, ALLOW_PLURAL | ALLOW_RING | NO_ZERODIVISOR}
,{D(jjHOMOG_P_W), HOMOG_CMD, POLY_CMD, POLY_CMD, POLY_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG_P_W), HOMOG_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG_ID_W), HOMOG_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG_ID_W), HOMOG_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjHOMOG_W_M), HOMOG_CMD, INT_CMD, MODUL_CMD, INTVEC_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(lInsert3), INSERT_CMD, LIST_CMD, LIST_CMD, DEF_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjINTERSEC3S), INTERSECT_CMD,IDEAL_CMD,IDEAL_CMD, IDEAL_CMD, STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjINTERSEC3S), INTERSECT_CMD,MODUL_CMD,MODUL_CMD, MODUL_CMD, STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjINTERSECT3), INTERSECT_CMD,IDEAL_CMD,IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjINTERSECT3), INTERSECT_CMD,MODUL_CMD,MODUL_CMD, MODUL_CMD, MODUL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjINTMAT3), INTMAT_CMD, INTMAT_CMD, INTMAT_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjJET_P_IV), JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, INTVEC_CMD, ALLOW_PLURAL }
,{D(jjJET_ID_IV), JET_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, INTVEC_CMD, ALLOW_PLURAL }
,{D(jjJET_P_IV), JET_CMD, VECTOR_CMD, VECTOR_CMD, INT_CMD, INTVEC_CMD, ALLOW_PLURAL }
,{D(jjJET_ID_IV), JET_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, INTVEC_CMD, ALLOW_PLURAL }
,{D(jjJET_P_P), JET_CMD, POLY_CMD, POLY_CMD, POLY_CMD, INT_CMD, ALLOW_PLURAL }
,{D(jjJET_P_P), JET_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, INT_CMD, ALLOW_PLURAL }
,{D(jjJET_ID_M), JET_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, INT_CMD, ALLOW_PLURAL }
,{D(jjJET_ID_M), JET_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD, INT_CMD, ALLOW_PLURAL }
,{ jjWRONG3 , JET_CMD, POLY_CMD, POLY_CMD, INT_CMD, INT_CMD, ALLOW_PLURAL }
,{D(mpKoszul), KOSZUL_CMD, MATRIX_CMD, INT_CMD, INT_CMD, IDEAL_CMD, NO_NC |NO_RING}
,{D(jjLIFT3), LIFT_CMD, MATRIX_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLIFT3), LIFT_CMD, MATRIX_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLIFTSTD_SYZ), LIFTSTD_CMD,IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, MODUL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLIFTSTD_SYZ), LIFTSTD_CMD,MODUL_CMD, MODUL_CMD, MATRIX_CMD, MODUL_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLIFTSTD_ALG), LIFTSTD_CMD,IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjLIFTSTD_ALG), LIFTSTD_CMD,MODUL_CMD, MODUL_CMD, MATRIX_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMATRIX_Id), MATRIX_CMD, MATRIX_CMD, IDEAL_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMATRIX_Mo), MATRIX_CMD, MATRIX_CMD, MODUL_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMATRIX_Ma), MATRIX_CMD, MATRIX_CMD, MATRIX_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMODULO3), MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMODULO3S), MODULO_CMD, MODUL_CMD, IDEAL_CMD, IDEAL_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMODULO3), MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMODULO3S), MODULO_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjMRES_MAP), MRES_MAP_CMD,RESOLUTION_CMD,IDEAL_CMD,INT_CMD, SMATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjMRES_MAP), MRES_MAP_CMD,RESOLUTION_CMD,MODUL_CMD,INT_CMD, SMATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSMATRIX_Mo), SMATRIX_CMD,SMATRIX_CMD,MODUL_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjSMATRIX_Mo), SMATRIX_CMD,SMATRIX_CMD,SMATRIX_CMD,INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
#ifdef OLD_RES
,{D(jjRES3), MRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
,{D(jjRES3), MRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
#endif
,{D(jjNEWSTRUCT3), NEWSTRUCT_CMD, NONE, STRING_CMD, STRING_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjPREIMAGE), PREIMAGE_CMD, IDEAL_CMD, RING_CMD, ANY_TYPE, ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
,{D(jjRANDOM_Im), RANDOM_CMD, INTMAT_CMD, INT_CMD, INT_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjRANDOM_CF), RANDOM_CMD, CNUMBER_CMD, CNUMBER_CMD, CNUMBER_CMD, CRING_CMD, ALLOW_NC |ALLOW_RING}
#endif
,{D(jjREDUCE3_P), REDUCE_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE3_P), REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, IDEAL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE3_P), REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, MODUL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE3_ID), REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE3_ID), REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE3_ID), REDUCE_CMD, MODUL_CMD, MODUL_CMD, IDEAL_CMD, INT_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE3_CP), REDUCE_CMD, POLY_CMD, POLY_CMD, POLY_CMD, IDEAL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjREDUCE3_CP), REDUCE_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, MODUL_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjREDUCE3_CID), REDUCE_CMD, IDEAL_CMD, IDEAL_CMD, IDEAL_CMD, MATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjREDUCE3_CID), REDUCE_CMD, MODUL_CMD, MODUL_CMD, MODUL_CMD, MATRIX_CMD, ALLOW_PLURAL |ALLOW_RING}
#ifdef OLD_RES
,{D(jjRES3), RES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
,{D(jjRES3), RES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
#endif
,{D(jjRESULTANT), RESULTANT_CMD, POLY_CMD,POLY_CMD, POLY_CMD, POLY_CMD, NO_NC |ALLOW_RING}
,{D(jjRING3), RING_CMD, RING_CMD, DEF_CMD, DEF_CMD, DEF_CMD, ALLOW_PLURAL |ALLOW_RING}
#ifdef OLD_RES
,{D(jjRES3), SRES_CMD, NONE, IDEAL_CMD, INT_CMD, ANY_TYPE, NO_NC |ALLOW_RING}
,{D(jjRES3), SRES_CMD, NONE, MODUL_CMD, INT_CMD, ANY_TYPE, NO_NC |ALLOW_RING}
#endif
,{D(jjSBA_2), SBA_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSBA_2), SBA_CMD, MODUL_CMD, MODUL_CMD, INT_CMD, INT_CMD, ALLOW_PLURAL |ALLOW_RING}
,{D(jjSTATUS3), STATUS_CMD, INT_CMD, LINK_CMD, STRING_CMD, STRING_CMD, ALLOW_NC |ALLOW_RING}
,{D(jjSTD_HILB_W), STD_CMD, IDEAL_CMD, IDEAL_CMD, BIGINTVEC_CMD,INTVEC_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjSTD_HILB_W), STD_CMD, MODUL_CMD, MODUL_CMD, BIGINTVEC_CMD,INTVEC_CMD, ALLOW_PLURAL |NO_RING}
,{D(jjSUBST_Bu), SUBST_CMD, ANY_TYPE, DEF_CMD, POLY_CMD, BUCKET_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSUBST_P), SUBST_CMD, POLY_CMD, POLY_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSUBST_P), SUBST_CMD, VECTOR_CMD, VECTOR_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSUBST_Id), SUBST_CMD, IDEAL_CMD, IDEAL_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSUBST_Id), SUBST_CMD, MODUL_CMD, MODUL_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSUBST_Id), SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, POLY_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSUBST_Id_I), SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, INT_CMD , ALLOW_NC |ALLOW_RING}
,{D(jjSUBST_Id_N), SUBST_CMD, MATRIX_CMD, MATRIX_CMD, POLY_CMD, NUMBER_CMD , ALLOW_NC |ALLOW_RING}
,{D(nuLagSolve), LAGSOLVE_CMD,LIST_CMD, POLY_CMD, INT_CMD, INT_CMD , NO_NC |NO_RING}
,{D(nuVanderSys), VANDER_CMD, POLY_CMD, IDEAL_CMD, IDEAL_CMD, INT_CMD , NO_NC |NO_RING}
,{NULL_VAL, 0, 0, 0, 0, 0 , NO_NC |NO_RING}
};
atATTRIB3
BOOLEAN atATTRIB3(leftv, leftv v, leftv b, leftv c)
Definition attrib.cc:374
jjWRONG3
#define jjWRONG3
Definition gentable.cc:126
jjBRACK_Bim
static BOOLEAN jjBRACK_Bim(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:5840
jjMATRIX_Mo
static BOOLEAN jjMATRIX_Mo(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6973
jjFWALK3
static BOOLEAN jjFWALK3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6215
jjBRACK_Ma_IV_I
static BOOLEAN jjBRACK_Ma_IV_I(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:5976
jjSUBST_Id_I
static BOOLEAN jjSUBST_Id_I(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6932
jjSUBST_Bu
static BOOLEAN jjSUBST_Bu(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6836
jjREDUCE3_ID
static BOOLEAN jjREDUCE3_ID(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7225
jjELIMIN_HILB
static BOOLEAN jjELIMIN_HILB(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6175
jjSTD_HILB_W
static BOOLEAN jjSTD_HILB_W(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7288
jjMODULO3
static BOOLEAN jjMODULO3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7012
jjCOEFFS3_P
static BOOLEAN jjCOEFFS3_P(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6140
jjJET_ID_IV
static BOOLEAN jjJET_ID_IV(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6372
jjMATRIX_Id
static BOOLEAN jjMATRIX_Id(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6950
jjSUBST_P
static BOOLEAN jjSUBST_P(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6849
jjLIFTSTD_SYZ
static BOOLEAN jjLIFTSTD_SYZ(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7149
jjBAREISS3
static BOOLEAN jjBAREISS3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6095
jjJET_ID_M
static BOOLEAN jjJET_ID_M(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6378
jjCOEFFS3_Id
static BOOLEAN jjCOEFFS3_Id(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6120
jjHOMOG_W_M
static BOOLEAN jjHOMOG_W_M(leftv res, leftv v1, leftv v2, leftv v3)
Definition iparith.cc:6312
jjRING_2
static BOOLEAN jjRING_2(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6083
jjBRACK_Im
static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:5813
jjMATRIX_Ma
static BOOLEAN jjMATRIX_Ma(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6986
jjPROC3
static BOOLEAN jjPROC3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6076
jjREDUCE3_CP
static BOOLEAN jjREDUCE3_CP(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7194
jjBRACK_Ma_I_IV
static BOOLEAN jjBRACK_Ma_I_IV(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:5926
jjINTERSEC3S
static BOOLEAN jjINTERSEC3S(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6347
jjRES3
static BOOLEAN jjRES3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7233
jjJET_P_IV
static BOOLEAN jjJET_P_IV(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6355
jjSTATUS3
static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7279
jjRING3
static BOOLEAN jjRING3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7274
jjFRES3
static BOOLEAN jjFRES3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:2312
jjREDUCE3_P
static BOOLEAN jjREDUCE3_P(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7218
jjHILBERT3Qt
static BOOLEAN jjHILBERT3Qt(leftv, leftv u, leftv v, leftv w)
Definition iparith.cc:6254
jjELIMIN_ALG
static BOOLEAN jjELIMIN_ALG(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6167
jjJET_P_P
static BOOLEAN jjJET_P_P(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6362
jjREDUCE3_CID
static BOOLEAN jjREDUCE3_CID(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7206
jjINTERSECT3
static BOOLEAN jjINTERSECT3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6334
jjBRACK_Ma
static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:5868
jjNEWSTRUCT3
static BOOLEAN jjNEWSTRUCT3(leftv, leftv u, leftv v, leftv w)
Definition iparith.cc:6668
jjHOMOG_P_W
static BOOLEAN jjHOMOG_P_W(leftv res, leftv u, leftv v, leftv)
Definition iparith.cc:6294
jjSUBST_Id
static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6882
jjSMATRIX_Mo
static BOOLEAN jjSMATRIX_Mo(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7114
jjPREIMAGE
static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6678
jjBRACK_Ma_IV_IV
static BOOLEAN jjBRACK_Ma_IV_IV(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6025
jjMRES_MAP
static BOOLEAN jjMRES_MAP(leftv res, leftv u, leftv v, leftv ma)
Definition iparith.cc:6585
jjLIFT3
static BOOLEAN jjLIFT3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7127
jjHOMOG_ID_W
static BOOLEAN jjHOMOG_ID_W(leftv res, leftv u, leftv v, leftv)
Definition iparith.cc:6276
jjFIND3
static BOOLEAN jjFIND3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6184
jjMODULO3S
static BOOLEAN jjMODULO3S(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7063
jjINTMAT3
static BOOLEAN jjINTMAT3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6320
jjBRACKET_REC
static BOOLEAN jjBRACKET_REC(leftv res, leftv a, leftv b, leftv c)
Definition iparith.cc:2945
jjRANDOM_Im
static BOOLEAN jjRANDOM_Im(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6761
jjCOEFFS3_KB
static BOOLEAN jjCOEFFS3_KB(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6134
jjHILBERT3
static BOOLEAN jjHILBERT3(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6224
jjLIFTSTD_ALG
static BOOLEAN jjLIFTSTD_ALG(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:7172
jjBRACK_S
static BOOLEAN jjBRACK_S(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:5797
jjSUBST_Id_N
static BOOLEAN jjSUBST_Id_N(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:6936
jjSBA_2
static BOOLEAN jjSBA_2(leftv res, leftv v, leftv u, leftv t)
Definition iparith.cc:5136
jjBRACK_SM
static BOOLEAN jjBRACK_SM(leftv res, leftv u, leftv v, leftv w)
Definition iparith.cc:5897
mpKoszul
BOOLEAN mpKoszul(leftv res, leftv c, leftv b, leftv id)
Definition ipshell.cc:3086
jjRESULTANT
BOOLEAN jjRESULTANT(leftv res, leftv u, leftv v, leftv w)
Definition ipshell.cc:3342
lInsert3
BOOLEAN lInsert3(leftv res, leftv u, leftv v, leftv w)
Definition lists.cc:135
nuLagSolve
BOOLEAN nuLagSolve(leftv res, leftv arg1, leftv arg2, leftv arg3)
find the (complex) roots an univariate polynomial Determines the roots of an univariate polynomial us...
Definition ipshell.cc:4681
nuVanderSys
BOOLEAN nuVanderSys(leftv res, leftv arg1, leftv arg2, leftv arg3)
COMPUTE: polynomial p with values given by v at points p1,..,pN derived from p; more precisely: consi...
Definition ipshell.cc:4824
VANDER_CMD
@ VANDER_CMD
Definition tok.h:200
SUBST_CMD
@ SUBST_CMD
Definition tok.h:188
MRES_MAP_CMD
@ MRES_MAP_CMD
Definition tok.h:132
RESULTANT_CMD
@ RESULTANT_CMD
Definition tok.h:173

## dArithM

const struct sValCmdM dArithM[]

extern

Definition at line 937 of file table.h.

{
// operations:
// proc cmd res number_of_args context
{D(jjKLAMMER_PL), '(', ANY_TYPE, -2 , ALLOW_NC |ALLOW_RING}
,{D(jjRING_PL), '[', RING_CMD, -2 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL1ARG), BIGINTVEC_CMD, BIGINTVEC_CMD, 1 , ALLOW_NC |ALLOW_RING}
,{D(jjBIGINTVEC_PL), BIGINTVEC_CMD,BIGINTVEC_CMD, -1 , ALLOW_NC |ALLOW_RING}
,{D(jjBREAK0), BREAKPOINT_CMD, NONE, 0 , ALLOW_NC |ALLOW_RING}
,{D(jjBREAK1), BREAKPOINT_CMD, NONE, -2 , ALLOW_NC |ALLOW_RING}
,{D(iiBranchTo), BRANCHTO_CMD, NONE, -2 , ALLOW_NC |ALLOW_RING}
#ifdef SINGULAR_4_2
,{D(jjCALL3ARG), CMATRIX_CMD, CMATRIX_CMD, 3 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), CNUMBER_CMD, CNUMBER_CMD, 2 , ALLOW_NC |ALLOW_RING}
#endif
,{D(jjCALL2ARG), COEF_CMD, MATRIX_CMD, 2 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCOEF_M), COEF_CMD, NONE, 4 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL2ARG), DIVISION_CMD, LIST_CMD, 2 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjDIVISION4), DIVISION_CMD, LIST_CMD, 3 , NO_NC |NO_RING}
,{D(jjDIVISION4), DIVISION_CMD, LIST_CMD, 4 , NO_NC |NO_RING}
,{D(jjDBPRINT), DBPRINT_CMD, NONE, -2 , ALLOW_NC |ALLOW_RING}
//,{D(jjEXPORTTO_M), EXPORTTO_CMD, NONE, -2 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), FETCH_CMD, ANY_TYPE/*or set by p*/,2 , ALLOW_NC |ALLOW_RING}
,{D(jjFETCH_M), FETCH_CMD, ANY_TYPE/*or set by p*/,3 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjFETCH_M), FETCH_CMD, ANY_TYPE/*or set by p*/,4 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL1ARG), HILBERT_CMD, ANY_TYPE/*or set by p*/,1 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), HILBERT_CMD, ANY_TYPE/*or set by p*/,2 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL3ARG), HILBERT_CMD, ANY_TYPE/*or set by p*/,3 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL1ARG), IDEAL_CMD, IDEAL_CMD, 1 , ALLOW_NC |ALLOW_RING}
,{D(jjIDEAL_PL), IDEAL_CMD, IDEAL_CMD, -1 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), INTERSECT_CMD, IDEAL_CMD, 2 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL3ARG), INTERSECT_CMD, IDEAL_CMD, 3 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjINTERSECT_PL),INTERSECT_CMD, IDEAL_CMD, -2 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL1ARG), INTVEC_CMD, INTVEC_CMD, 1 , ALLOW_NC |ALLOW_RING}
,{D(jjINTVEC_PL), INTVEC_CMD, INTVEC_CMD, -1 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), JET_CMD, POLY_CMD,/*or set by p*/ 2 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL3ARG), JET_CMD, POLY_CMD,/*or set by p*/ 3 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjJET4), JET_CMD, POLY_CMD,/*or set by p*/ 4 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL1ARG), LIB_CMD, NONE, 1 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), LIFT_CMD, MATRIX_CMD, 2 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL3ARG), LIFT_CMD, MATRIX_CMD, 3 , ALLOW_NC |ALLOW_RING}
,{D(jjLIFT_4), LIFT_CMD, MATRIX_CMD, 4 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL2ARG), LIFTSTD_CMD, IDEAL_CMD,/*or MODUL*/2 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL3ARG), LIFTSTD_CMD, IDEAL_CMD,/*or MODUL*/3 , ALLOW_NC |ALLOW_RING}
,{D(jjLIFTSTD_M), LIFTSTD_CMD, IDEAL_CMD,/*or MODUL*/4 , ALLOW_NC |ALLOW_RING}
,{D(jjLIFTSTD_M), LIFTSTD_CMD, IDEAL_CMD,/*or MODUL*/5 , ALLOW_NC |ALLOW_RING}
,{D(jjLIST_PL), LIST_CMD, LIST_CMD, -1 , ALLOW_NC |ALLOW_RING}
,{D(jjLU_INVERSE),LUI_CMD, LIST_CMD, -2 , NO_NC |NO_RING}
,{D(jjLU_SOLVE), LUS_CMD, LIST_CMD, -2 , NO_NC |NO_RING}
,{ jjWRONG , MINOR_CMD, NONE, 1 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjMINOR_M), MINOR_CMD, IDEAL_CMD, -2 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL1ARG), MODUL_CMD, MODUL_CMD, 1 , ALLOW_NC |ALLOW_RING}
,{D(jjIDEAL_PL), MODUL_CMD, MODUL_CMD, -1 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), MODULO_CMD, MODUL_CMD, 2 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL3ARG), MODULO_CMD, MODUL_CMD, 3 , ALLOW_NC |ALLOW_RING}
,{D(jjMODULO4), MODULO_CMD, MODUL_CMD, 4 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL1ARG), NAMES_CMD, LIST_CMD, 1 , ALLOW_NC |ALLOW_RING}
,{D(jjNAMES0), NAMES_CMD, LIST_CMD, 0 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), CNUMBER_CMD, CNUMBER_CMD, 2 , ALLOW_NC |ALLOW_RING}
,{D(jjOPTION_PL), OPTION_CMD, STRING_CMD/*or set by p*/,-1, ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), REDUCE_CMD, IDEAL_CMD/*or set by p*/, 2, ALLOW_NC |ALLOW_RING}
,{D(jjCALL3ARG), REDUCE_CMD, IDEAL_CMD/*or set by p*/, 3, ALLOW_NC |ALLOW_RING}
,{D(jjREDUCE4), REDUCE_CMD, IDEAL_CMD/*or set by p*/, 4, ALLOW_PLURAL |ALLOW_RING}
,{D(jjREDUCE5), REDUCE_CMD, IDEAL_CMD/*or set by p*/, 5, ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL1ARG), RESERVEDNAME_CMD, INT_CMD, 1 , ALLOW_NC |ALLOW_RING}
,{D(jjRESERVED0), RESERVEDNAME_CMD, NONE, 0 , ALLOW_NC |ALLOW_RING}
//,{D(jjCALL1ARG), RESERVEDNAMELIST_CMD, LIST_CMD, 1 , ALLOW_NC |ALLOW_RING}
,{D(jjRESERVEDLIST0), RESERVEDNAMELIST_CMD, LIST_CMD, 0 , ALLOW_NC |ALLOW_RING}
,{D(jjSTRING_PL), STRING_CMD, STRING_CMD, -1 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL3ARG), SUBST_CMD, NONE/*set by p*/, 3 , ALLOW_NC |ALLOW_RING}
,{D(jjSUBST_M), SUBST_CMD, NONE/*set by p*/, -2 , ALLOW_NC |ALLOW_RING}
,{D(jjSYSTEM), SYSTEM_CMD, NONE/*or set by p*/,-2 , ALLOW_NC |ALLOW_RING}
,{D(jjTEST), TEST_CMD, NONE, -2 , ALLOW_NC |ALLOW_RING}
,{D(iiWRITE), WRITE_CMD, NONE, -2 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), STATUS_CMD, STRING_CMD, 2 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL3ARG), STATUS_CMD, INT_CMD, 3 , ALLOW_NC |ALLOW_RING}
,{D(jjSTATUS_M), STATUS_CMD, INT_CMD, 4 , ALLOW_NC |ALLOW_RING}
,{D(loSimplex), SIMPLEX_CMD, LIST_CMD, 6 , NO_NC |NO_RING}
,{D(nuUResSolve), URSOLVE_CMD, LIST_CMD, 4 , NO_NC |NO_RING}
,{D(jjCALL1ARG), STD_CMD, IDEAL_CMD/* or set by p*/,1 , ALLOW_NC |ALLOW_RING}
,{D(jjCALL2ARG), STD_CMD, IDEAL_CMD, 2 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjCALL3ARG), STD_CMD, IDEAL_CMD, 3 , NO_NC |ALLOW_RING}
,{D(jjSTD_HILB_WP), STD_CMD, IDEAL_CMD, 4 , NO_NC |NO_RING}
,{D(jjQRDS), QRDS_CMD, LIST_CMD, 4 , ALLOW_PLURAL |ALLOW_RING}
,{D(jjFactModD_M),FMD_CMD, LIST_CMD, -2 , NO_NC |NO_RING}
,{NULL_VAL, 0, 0, 0 , NO_NC |NO_RING}
};
jjSYSTEM
BOOLEAN jjSYSTEM(leftv res, leftv args)
Definition extra.cc:227
jjRESERVEDLIST0
static BOOLEAN jjRESERVEDLIST0(leftv res, leftv)
Definition iparith.cc:8524
jjOPTION_PL
static BOOLEAN jjOPTION_PL(leftv res, leftv v)
Definition iparith.cc:8373
jjREDUCE5
static BOOLEAN jjREDUCE5(leftv res, leftv u)
Definition iparith.cc:8454
jjLU_SOLVE
static BOOLEAN jjLU_SOLVE(leftv res, leftv v)
Definition iparith.cc:7819
jjFactModD_M
static BOOLEAN jjFactModD_M(leftv res, leftv v)
Definition iparith.cc:8657
jjRESERVED0
static BOOLEAN jjRESERVED0(leftv, leftv)
Definition iparith.cc:8502
jjLIFT_4
static BOOLEAN jjLIFT_4(leftv res, leftv U)
Definition iparith.cc:8129
jjBREAK1
static BOOLEAN jjBREAK1(leftv, leftv v)
Definition iparith.cc:7339
jjBREAK0
static BOOLEAN jjBREAK0(leftv, leftv)
Definition iparith.cc:7332
jjCOEF_M
static BOOLEAN jjCOEF_M(leftv, leftv v)
Definition iparith.cc:7380
jjMINOR_M
static BOOLEAN jjMINOR_M(leftv res, leftv v)
Definition iparith.cc:6389
jjINTERSECT_PL
static BOOLEAN jjINTERSECT_PL(leftv res, leftv v)
Definition iparith.cc:7664
jjBIGINTVEC_PL
static BOOLEAN jjBIGINTVEC_PL(leftv res, leftv v)
Definition iparith.cc:7932
jjRING_PL
static BOOLEAN jjRING_PL(leftv res, leftv a)
Definition iparith.cc:8948
jjREDUCE4
static BOOLEAN jjREDUCE4(leftv res, leftv u)
Definition iparith.cc:8383
jjTEST
static BOOLEAN jjTEST(leftv, leftv v)
Definition iparith.cc:8638
jjDIVISION4
static BOOLEAN jjDIVISION4(leftv res, leftv v)
Definition iparith.cc:7397
jjSTD_HILB_WP
static BOOLEAN jjSTD_HILB_WP(leftv res, leftv INPUT)
Definition iparith.cc:8864
jjLIFTSTD_M
static BOOLEAN jjLIFTSTD_M(leftv res, leftv U)
Definition iparith.cc:8160
jjSTRING_PL
static BOOLEAN jjSTRING_PL(leftv res, leftv v)
Definition iparith.cc:8604
jjCALL3ARG
static BOOLEAN jjCALL3ARG(leftv res, leftv u)
Definition iparith.cc:7368
jjINTVEC_PL
static BOOLEAN jjINTVEC_PL(leftv res, leftv v)
Definition iparith.cc:7900
jjMODULO4
static BOOLEAN jjMODULO4(leftv res, leftv u)
Definition iparith.cc:8301
jjLU_INVERSE
static BOOLEAN jjLU_INVERSE(leftv res, leftv v)
Definition iparith.cc:7738
jjQRDS
static BOOLEAN jjQRDS(leftv res, leftv INPUT)
Definition iparith.cc:8847
jjFETCH_M
static BOOLEAN jjFETCH_M(leftv res, leftv u)
Definition iparith.cc:7539
jjNAMES0
static BOOLEAN jjNAMES0(leftv res, leftv)
Definition iparith.cc:8368
jjJET4
static BOOLEAN jjJET4(leftv res, leftv u)
Definition iparith.cc:7993
jjSTATUS_M
static BOOLEAN jjSTATUS_M(leftv res, leftv v)
Definition iparith.cc:8789
jjCALL1ARG
static BOOLEAN jjCALL1ARG(leftv res, leftv v)
Definition iparith.cc:7356
jjLIST_PL
BOOLEAN jjLIST_PL(leftv res, leftv v)
Definition iparith.cc:8250
jjCALL2ARG
static BOOLEAN jjCALL2ARG(leftv res, leftv u)
Definition iparith.cc:7360
jjKLAMMER_PL
static BOOLEAN jjKLAMMER_PL(leftv res, leftv u)
Definition iparith.cc:8076
jjSUBST_M
static BOOLEAN jjSUBST_M(leftv res, leftv u)
Definition iparith.cc:8820
jjIDEAL_PL
static BOOLEAN jjIDEAL_PL(leftv res, leftv v)
Definition iparith.cc:7496
jjDBPRINT
BOOLEAN jjDBPRINT(leftv res, leftv u)
Definition ipprint.cc:318
iiBranchTo
BOOLEAN iiBranchTo(leftv, leftv args)
Definition ipshell.cc:1281
iiWRITE
BOOLEAN iiWRITE(leftv res, leftv v)
Definition ipshell.cc:587
loSimplex
BOOLEAN loSimplex(leftv res, leftv args)
Implementation of the Simplex Algorithm.
Definition ipshell.cc:4572
nuUResSolve
BOOLEAN nuUResSolve(leftv res, leftv args)
solve a multipolynomial system using the u-resultant Input ideal must be 0-dimensional and (currRing-...
Definition ipshell.cc:4925
SIMPLEX_CMD
@ SIMPLEX_CMD
Definition tok.h:179
LUS_CMD
@ LUS_CMD
Definition tok.h:123
BRANCHTO_CMD
@ BRANCHTO_CMD
Definition tok.h:39
BREAKPOINT_CMD
@ BREAKPOINT_CMD
Definition tok.h:41
QRDS_CMD
@ QRDS_CMD
Definition tok.h:161
DBPRINT_CMD
@ DBPRINT_CMD
Definition tok.h:57
URSOLVE_CMD
@ URSOLVE_CMD
Definition tok.h:199
FMD_CMD
@ FMD_CMD
Definition tok.h:80
WRITE_CMD
@ WRITE_CMD
Definition tok.h:208
RESERVEDNAMELIST_CMD
@ RESERVEDNAMELIST_CMD
Definition tok.h:171
MINOR_CMD
@ MINOR_CMD
Definition tok.h:126
LUI_CMD
@ LUI_CMD
Definition tok.h:122
TEST_CMD
@ TEST_CMD
Definition tok.h:192
SYSTEM_CMD
@ SYSTEM_CMD
Definition tok.h:189

## iiCurrArgs

EXTERN_VAR leftv iiCurrArgs

Definition at line 29 of file ipshell.h.

## iiCurrProc

EXTERN_VAR idhdl iiCurrProc

Definition at line 30 of file ipshell.h.

## iiLocalRing

EXTERN_VAR ring* iiLocalRing

Definition at line 35 of file ipshell.h.

## iiOp

EXTERN_VAR int iiOp

Definition at line 31 of file ipshell.h.

## iiRETURNEXPR

EXTERN_INST_VAR sleftv iiRETURNEXPR

Definition at line 34 of file ipshell.h.

## iiRETURNEXPR_len

EXTERN_VAR int iiRETURNEXPR_len

Definition at line 33 of file ipshell.h.

## lastreserved

const char* lastreserved

extern

Definition at line 83 of file ipshell.cc.

## myynest

EXTERN_VAR int myynest

Definition at line 38 of file ipshell.h.

## printlevel

EXTERN_VAR int printlevel

Definition at line 39 of file ipshell.h.

## si_echo

EXTERN_VAR int si_echo

Definition at line 40 of file ipshell.h.

## yyInRingConstruction

EXTERN_VAR BOOLEAN yyInRingConstruction

Definition at line 43 of file ipshell.h.