72 ch[0]=c->op;ch[1]=
'\0';
75 ::Print(
"##command %d(%s), %d args\n",
78 c->arg1.Print(
NULL,spaces+2);
82 c->arg2.Print(
NULL,spaces+2);
84 c->arg3.Print(
NULL,spaces+2);
145 ((
intvec *)d)->show(t,spaces);
150 const ring r = (
const ring)d;
293 l->m[
i].Print(
NULL,spaces+3);
305 if (bb!=
NULL) { bb->blackbox_Print(bb,d); }
306 else {
::Print(
"Print: blackbox %d(bb=NULL)",t); }
311 if ((store!=
NULL)&&(store!=
this))
442 return (
void*)n2Copy((number2)d);
444 return (
void*)p2Copy((poly2)d);
459 return (
void *)
idCopy((ideal)d);
468 return (
void *)
pCopy((poly)d);
472 return (
void *)
nCopy((number)d);
503 if (
b!=
NULL)
return b->blackbox_Copy(
b,d);
507 Warn(
"s_internalCopy: cannot copy type %s(%d)",
535 number2 n=(number2)d;
628 Print(
"currRing? ref=%d\n",
R->ref);
641 if (cmd->arg1.rtyp!=0) cmd->arg1.CleanUp(r);
642 if (cmd->arg2.rtyp!=0) cmd->arg2.CleanUp(r);
643 if (cmd->arg3.rtyp!=0) cmd->arg3.CleanUp(r);
675 if (
b!=
NULL)
b->blackbox_destroy(
b,d);
679 Warn(
"s_internalDelete: cannot delete type %s(%d)",
696 else if (e->next==
NULL)
718 void *d=source->
Data();
810 sprintf(
s,
"int(%d)",(
int)(
long)d);
815 sprintf(
s,
"%d",(
int)(
long)d);
827 s = (
char*)
omAlloc(strlen((
char*) d) + 3);
828 sprintf(
s,
"\"%s\"", (
char*) d);
841 s = (
char*)
omAlloc(strlen(ps) + 10);
842 sprintf(
s,
"%s(%s)", (t ==
POLY_CMD ?
"poly" :
"vector"), ps);
853 return n2String((number2)d,typed);
888 char* ns = (
char*)
omAlloc(strlen(
s) + 40);
889 sprintf(ns,
"matrix(ideal(%s),%d,%d)",
s,
906 char* ns = (
char*)
omAlloc(strlen(
s) + 10);
908 sprintf(ns,
"ideal(%s)",
s);
910 sprintf(ns,
"module(%s)",
s);
927 ns = (
char*)
omAlloc(strlen(
s) + 40);
928 sprintf(ns,
"intmat(intvec(%s),%d,%d)",
s,
v->rows(),
v->cols());
932 ns = (
char*)
omAlloc(strlen(
s) + 10);
933 sprintf(ns,
"intvec(%s)",
s);
948 char* ns = (
char*)
omAlloc0(strlen(
s) + 40);
949 sprintf(ns,
"bigintmat(bigintvec(%s),%d,%d)",
s, bim->
rows(), bim->
cols());
968 ns = (
char*)
omAlloc(strlen(
s) + strlen(
id) + 20);
969 sprintf(ns,
"\"%s\";%sideal(%s)",
s,(
dim == 2 ?
"\n" :
" "),
id);
973 ns = (
char*)
omAlloc(strlen(
s) + 4);
974 sprintf(ns,
"\"%s\"",
s);
993 s = (
pi->data.s.body);
998 char* ns = (
char*)
omAlloc(strlen(
s) + 4);
999 sprintf(ns,
"\"%s\"",
s);
1010 char* ns = (
char*)
omAlloc(strlen(
s) + 10);
1011 sprintf(ns,
"link(\"%s\")",
s);
1025 if (bb!=
NULL)
return bb->blackbox_String(bb,d);
1044 return ((
idhdl)
h->data.ustring)->typ;
1118 if ((0<
e->start)&&(
e->start<=
l->nr+1))
1120 Subexpr tmp=
l->m[
e->start-1].e;
1121 l->m[
e->start-1].e=
e->next;
1122 r=
l->m[
e->start-1].Typ();
1123 e->next=
l->m[
e->start-1].e;
1124 l->m[
e->start-1].e=tmp;
1154 if ((0<
e->start)&&(
e->start<=
l->nr+1))
1156 l->m[
e->start-1].e=
e->next;
1157 r=
l->m[
e->start-1].LTyp();
1187 return ((
idhdl)
h->data.ustring)->
data.ustring;
1208 return (
void *)
A->qideal->m[0];
1211 return (
void *)
nInit(0);
1251 r=(
char *)(
long)((*iv)[
index-1]);
1259 ||(
e->next->start<1)
1260 ||(
e->next->start>iv->
cols()))
1263 Werror(
"wrong range[%d,%d] in intmat %s(%dx%d)",
index,
e->next->start,
1264 this->Name(),iv->
rows(),iv->
cols());
1275 ||(
e->next->start<1)
1276 ||(
e->next->start>
m->cols()))
1279 Werror(
"wrong range[%d,%d] in bigintmat %s(%dx%d)",
index,
e->next->start,
1280 this->Name(),
m->rows(),
m->cols());
1292 ||(
e->next->start<1)
1293 ||(
e->next->start>
m->cols()))
1296 Werror(
"wrong range[%d,%d] in matrix %s(%dx%d)",
index,
e->next->start,
1297 this->Name(),
m->rows(),
m->cols());
1301 iiNumber2Data[iiCmatrix_index].cf=
m->basecoeffs();
1303 r=(
char*)&iiNumber2Data[iiCmatrix_index];
1304 iiCmatrix_index=(iiCmatrix_index+1) % 4;
1320 r=(
char *)I->m[
index-1];
1332 && ((c=
e->next->start)>0) &&(c<=
IDELEMS(I)))
1346 memcpy(
this,&tmp,
sizeof(tmp));
1371 if ((
index>0)&& (
index<=(int)strlen((
char *)d)))
1373 r[0]=*(((
char *)d)+
index-1);
1388 memcpy(
this,&tmp,
sizeof(tmp));
1408 ||(
e->next->start<1)
1412 Werror(
"wrong range[%d,%d] in matrix %s(%dx%d)",
1437 char *dd=(
char *)
l->m[
index-1].data;
1438 int j=
e->next->start-1;
1440 if ((
j>=0) && (
j<(
int)strlen(dd)))
1452 Subexpr tmp=
l->m[
index-1].e;
1454 r=(
char *)
l->m[
index-1].Data();
1479 return &(
v->attribute);
1508 if ((0>=
e->start)||(
e->start>
l->nr+1))
1512 l->m[
e->start-1].e=
e->next;
1513 leftv r=
l->m[
e->start-1].LData();
1517 return &(
l->m[
e->start-1]);
1524 leftv sleftv::LHdl()
1536 if ((0>=
e->start)||(
e->start>
l->nr+1))
1540 l->m[
e->start-1].e=
e->next;
1541 leftv r=
l->m[
e->start-1].LHdl();
1545 return &(
l->m[
e->start-1]);
1566 Warn(
"%s is no standard basis",
h->Name());
1595 if ((*
id<
' ')||(*
id>(
char)126))
1597 Print(
"wrong id :%s:\n",
id);
1604 v->req_packhdl =
pa;
1614 if (!isdigit(
id[0]))
1616 if (strcmp(
id,
"basering")==0)
1630 else if (strcmp(
id,
"Current")==0)
1646 h=
v->req_packhdl->idroot->get(
id,
myynest);
1671 v->data = (
void *)
p;
1682 if (ok && (
p!=
NULL))
1709 v->data = (
void *)
nInit(0);
1729 #ifdef HAVE_SHIFTBBA
1756 v->data = (
void *)
nInit(0);
1813 if (strcmp(
id,
"_")==0)
1838 v->data = (
char *)
h;
1864 char *what=(
char *)(d->arg1.Data());
1882 else if (d->op==
'=')
1890 const char *n=d->arg1.name;
1891 nok=(n ==
NULL) || d->arg2.Eval();
1894 int save_typ=d->arg1.rtyp;
1896 if (d->arg1.rtyp!=
IDHDL)
1899 if (d->arg1.rtyp==
IDHDL)
1914 memcpy(&d->arg1,&t,
sizeof(
sleftv));
1916 nok=nok||
iiAssign(&d->arg1,&d->arg2);
1921 memset(&d->arg1,0,
sizeof(
sleftv));
1933 if ((toktype==
CMD_M)
1939 if (d->argc>=1) nok=d->arg1.Eval();
1940 if ((!nok) && (d->argc>=2))
1944 memcpy(d->arg1.next,&d->arg2,
sizeof(
sleftv));
1947 if ((!nok) && (d->argc==3))
1951 memcpy(d->arg1.next->next,&d->arg3,
sizeof(
sleftv));
1965 else if (d->argc==1)
1973 nok=nok||d->arg2.Eval();
1979 nok=nok||d->arg2.Eval();
1980 nok=nok||d->arg3.Eval();
1981 nok=nok||
iiExprArith3(&tmp,d->op,&d->arg1,&d->arg2,&d->arg3);
1993 memcpy(
this,&tmp,
sizeof(tmp));
2021 ideal
id=(ideal)
Data();
2023 int i=
id->ncols*
id->nrows-1;
bigintmat * bimCopy(const bigintmat *b)
same as copy constructor - apart from it being able to accept NULL as input
#define BIMATELEM(M, I, J)
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
char * String()
IO: String returns a singular string containing the matrix, needs freeing afterwards.
void killAll(const ring r)
Class used for (list of) interpreter objects.
char * String(void *d=NULL, BOOLEAN typed=FALSE, int dim=1)
Called for conversion to string (used by string(..), write(..),..)
void CleanUp(ring r=currRing)
void Print(leftv store=NULL, int spaces=0)
Called by type_cmd (e.g. "r;") or as default in jPRINT.
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
static FORCE_INLINE char * nCoeffName(const coeffs cf)
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
@ n_long_C
complex floating point (GMP) numbers
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
void nKillChar(coeffs r)
undo all initialisations
BOOLEAN pa(leftv res, leftv args)
const CanonicalForm int s
const Variable & v
< [in] a sqrfree bivariate poly
VAR char my_yylinebuf[80]
void nfShowMipo(const coeffs r)
Show the mininimal polynom.... NOTE: this is used by char * sleftv::String(void *d,...
const char * Tok2Cmdname(int tok)
const char * iiTwoOps(int t)
VAR BOOLEAN yyInRingConstruction
ideal id_Copy(ideal h1, const ring r)
copy an ideal
#define IMATELEM(M, I, J)
intvec * ivCopy(const intvec *o)
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
void jjNormalizeQRingId(leftv I)
void jjNormalizeQRingP(poly &p)
BOOLEAN iiAssign(leftv l, leftv r, BOOLEAN toplevel)
VAR omBin sip_command_bin
const char * piProcinfo(procinfov pi, const char *request)
idhdl ggetid(const char *n)
void killhdl(idhdl h, package proot)
BOOLEAN piKill(procinfov pi)
package paCopy(package pack)
INST_VAR sleftv iiRETURNEXPR
BOOLEAN iiMake_proc(idhdl pn, package pack, leftv sl)
void ipPrint_MA0(matrix m, const char *name)
int iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring, BOOLEAN init_b)
BOOLEAN iiCheckRing(int i)
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
void paPrint(const char *n, package p)
BOOLEAN lRingDependend(lists L)
char * lString(lists l, BOOLEAN typed, int dim)
map maCopy(map theMap, const ring r)
char * iiStringMatrix(matrix im, int dim, const ring r, char ch)
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
void iiWriteMatrix(matrix im, const char *n, int dim, const ring r, int spaces)
set spaces to zero by default
#define MATELEM(mat, i, j)
1-based access to matrix
#define SMATELEM(A, i, j, R)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
The main handler for Singular numbers which are suitable for Singular polynomials.
#define omCheckAddr(addr)
#define omCheckIf(cond, test)
#define omCheckAddrSize(addr, size)
#define omFreeBin(addr, bin)
#define omFreeBinAddr(addr)
#define omGetSpecBin(size)
static int index(p_Length length, p_Ord ord)
static void p_LmDelete(poly p, const ring r)
static void p_Delete(poly *p, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
static long p_Totaldegree(poly p, const ring r)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Compatiblity layer for legacy polynomial operations (over currRing)
#define pIsConstant(p)
like above, except that Comp must be 0
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
#define pCopy(p)
return a copy of the poly
void StringSetS(const char *st)
void StringAppendS(const char *st)
void PrintNSpaces(const int n)
void PrintS(const char *s)
void Werror(const char *fmt,...)
void rWrite(ring r, BOOLEAN details)
int r_IsRingVar(const char *n, char **names, int N)
static BOOLEAN rField_is_GF(const ring r)
void sBucketPrint(sBucket_pt bucket)
void sBucketDeleteAndDestroy(sBucket_pt *bucket_pt)
sBucket_pt sBucketCopy(const sBucket_pt bucket)
Copy sBucket non-intrusive!!!
char * sBucketString(sBucket_pt bucket)
poly sBucketPeek(sBucket_pt b)
const char * slStatus(si_link l, const char *request)
static si_link slCopy(si_link l)
static char * slString(si_link l)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
matrix id_Module2Matrix(ideal mod, const ring R)
void syMake(leftv v, const char *id, package pa)
void s_internalDelete(const int t, void *d, const ring r)
STATIC_VAR omBin size_two_bin
static void * s_internalCopy(const int t, void *d)
INST_VAR sleftv sLastPrinted
void * slInternalCopy(leftv source, const int t, void *d, Subexpr e)
BOOLEAN assumeStdFlag(leftv h)
procinfov piCopy(procinfov pi)
syStrategy syCopy(syStrategy syzstr)
void syKillComputation(syStrategy syzstr, ring r=currRing)
void syPrint(syStrategy syzstr, const char *currRingName)