32 typedef void * (*iiConvertProc)(
void * data);
89 I->m[0]=
pISet((
int)(
long)data);
139 static void *
iiN2P(
void *data);
160 int s=(int)(
long)data;
167 number
n=
nInit((
int)(
long)data);
197 for (i=iv->
rows(); i>0; i--)
199 for (j=iv->
cols(); j>0; j--)
221 p=
pNSet((number)data);
262 int add_row_shift = 0;
264 if (weights!=
NULL) add_row_shift=weights->
min_in();
281 #define NULL_VAL NULL
289 memset(output,0,
sizeof(
sleftv));
290 if ((inputType==outputType)
294 memcpy(output,input,
sizeof(*output));
295 memset(input,0,
sizeof(*input));
301 output->
data=(
char *)(
long)input->
Typ();
332 sprintf(tmp,
"%c%d",*(
currRing->names[nr-1]),
350 number
n=(number)input->
data;
352 input->
data=(
void*)n;
359 memset(input,0,
sizeof(*input));
370 if((dConvertTypes[index].i_typ==inputType)
371 &&(dConvertTypes[index].o_typ==outputType))
375 Print(
"automatic conversion %s -> %s\n",
380 output->
rtyp=outputType;
381 if (dConvertTypes[index].
p!=
NULL)
387 dConvertTypes[
index].
pl(output,input);
412 if ((inputType==outputType)
414 || (outputType==
IDHDL)
425 while (dConvertTypes[i].i_typ!=0)
427 if((dConvertTypes[i].i_typ==inputType)
428 &&(dConvertTypes[i].o_typ==outputType))
static void * iiIm2Ma(void *data)
static void * iiP2Id(void *data)
static void * iiN2Ma(void *data)
const CanonicalForm int s
Class used for (list of) interpreter objects.
ideal idVec2Ideal(poly vec)
static void * iiBI2N(void *data)
int iiTestConvert(int inputType, int outputType, struct sConvertTypes *dConvertTypes)
Compatiblity layer for legacy polynomial operations (over currRing)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
bigintmat * iv2bim(intvec *b, const coeffs C)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static void * iiN2P(void *data)
const CanonicalForm CFMap CFMap int &both_non_zero int n
static void * iiIm2Bim(void *data)
static void * iiMa2Mo(void *data)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
static void iiR2L_l(leftv out, leftv in)
#define pGetComp(p)
Component.
static void * iiV2Ma(void *data)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
Coefficient rings, fields and other domains suitable for Singular polynomials.
static void * iiI2P(void *data)
static void * iiL2R(void *data)
BOOLEAN slInit(si_link l, char *istr)
void StringSetS(const char *st)
static void * iiI2N(void *data)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
static FORCE_INLINE void n_Write(number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
static void * iiP2V(void *data)
#define pIsConstant(p)
like above, except that Comp might be != 0
static void * iiS2Link(void *data)
matrix id_Module2Matrix(ideal mod, const ring R)
static void * iiDummy(void *data)
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
struct sConvertTypes dConvertTypes[]
static int index(p_Length length, p_Ord ord)
matrix mpNew(int r, int c)
create a r x c zero-matrix
ideal idInit(int idsize, int rank)
initialise an ideal / module
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
static void * iiMo2Ma(void *data)
const char * Tok2Cmdname(int tok)
static void * iiI2Id(void *data)
void *(* iiConvertProc)(void *data)
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, struct sConvertTypes *dConvertTypes)
static void * iiBI2Id(void *data)
static void * iiBI2P(void *data)
syStrategy syConvList(lists li, BOOLEAN toDel)
void(* iiConvertProcL)(leftv out, leftv in)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar...
#define IMATELEM(M, I, J)
static void * iiBI2V(void *data)
static void * iiI2BI(void *data)
ideal id_Matrix2Module(matrix mat, const ring R)
static void * iiI2Iv(void *data)
static void * iiI2V(void *data)
void Werror(const char *fmt,...)
#define MATELEM(mat, i, j)