My Project  debian-1:4.1.1-p2+ds-4build2
ipconv.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: automatic type conversions
6 */
7 
8 
9 
10 
11 #include "kernel/mod2.h"
12 #include "Singular/tok.h"
13 #include "Singular/ipid.h"
14 #include "misc/intvec.h"
15 #include "misc/options.h"
16 #include "omalloc/omalloc.h"
17 #include "kernel/polys.h"
18 #include "kernel/ideals.h"
19 #include "Singular/subexpr.h"
20 #include "coeffs/numbers.h"
21 #include "coeffs/coeffs.h"
22 #include "coeffs/bigintmat.h"
23 //#include "polys/ext_fields/longalg.h"
24 #include "polys/matpol.h"
25 #include "Singular/links/silink.h"
26 #include "kernel/GBEngine/syz.h"
27 #include "Singular/attrib.h"
28 #include "polys/monomials/ring.h"
29 #include "Singular/ipshell.h"
30 #include "Singular/number2.h"
31 #include "Singular/ipconv.h"
32 
33 typedef void * (*iiConvertProc)(void * data);
34 typedef void (*iiConvertProcL)(leftv out,leftv in);
35 struct sConvertTypes
36 {
37  int i_typ;
38  int o_typ;
41 };
42 
43 // all of these static conversion routines work destructive on their input
44 
45 static void * iiI2P(void *data)
46 {
47  poly p=pISet((int)(long)data);
48  return (void *)p;
49 }
50 
51 static void * iiBI2P(void *data)
52 {
54  if (nMap==NULL)
55  {
56  Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
57  return NULL;
58  }
59  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
60  n_Delete((number *)&data, coeffs_BIGINT);
61  poly p=p_NSet(n, currRing);
62  return (void *)p;
63 }
64 
65 static void * iiI2V(void *data)
66 {
67  poly p=pISet((int)(long)data);
68  if (p!=NULL) pSetComp(p,1);
69  return (void *)p;
70 }
71 
72 static void * iiBI2V(void *data)
73 {
75  if (nMap==NULL)
76  {
77  Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
78  return NULL;
79  }
80  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
81  n_Delete((number *)&data, coeffs_BIGINT);
82  poly p=p_NSet(n, currRing);
83  if (p!=NULL) pSetComp(p,1);
84  return (void *)p;
85 }
86 
87 static void * iiI2Id(void *data)
88 {
89  ideal I=idInit(1,1);
90  I->m[0]=pISet((int)(long)data);
91  return (void *)I;
92 }
93 
94 static void * iiBI2Id(void *data)
95 {
96  ideal I=idInit(1,1);
98  if (nMap==NULL)
99  {
100  Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
101  return NULL;
102  }
103  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
104  n_Delete((number *)&data,coeffs_BIGINT);
105  poly p=pNSet(n);
106  I->m[0]=p;
107  return (void *)I;
108 }
109 static void * iiP2V(void *data)
110 {
111  poly p=(poly)data;
112  if (p!=NULL) pSetCompP(p,1);
113  return (void *)p;
114 }
115 
116 static void * iiP2Id(void *data)
117 {
118  ideal I=idInit(1,1);
119 
120  if (data!=NULL)
121  {
122  poly p=(poly)data;
123  I->m[0]=p;
124  if (pGetComp(p)!=0) I->rank=pMaxComp(p);
125  }
126  return (void *)I;
127 }
128 
129 static void * iiV2Ma(void *data)
130 {
131  matrix m=(matrix)idVec2Ideal((poly)data);
132  int h=MATCOLS(m);
133  MATCOLS(m)=MATROWS(m);
134  MATROWS(m)=h;
135  m->rank=h;
136  pDelete((poly *)&data);
137  return (void *)m;
138 }
139 
140 static void * iiN2P(void *data);
141 
142 static void * iiDummy(void *data)
143 {
144  return data;
145 }
146 
147 static void * iiMo2Ma(void *data)
148 {
149  void *res=id_Module2Matrix((ideal)data,currRing);
150  return res;
151 }
152 
153 static void * iiMa2Mo(void *data)
154 {
155  void *res=id_Matrix2Module((matrix)data,currRing);
156  return res;
157 }
158 
159 static void * iiI2Iv(void *data)
160 {
161  int s=(int)(long)data;
162  intvec *iv=new intvec(s,s);
163  return (void *)iv;
164 }
165 
166 static void * iiI2N(void *data)
167 {
168  number n=nInit((int)(long)data);
169  return (void *)n;
170 }
171 
172 static void * iiI2BI(void *data)
173 {
174  number n=n_Init((int)(long)data, coeffs_BIGINT);
175  return (void *)n;
176 }
177 
178 #ifdef SINGULAR_4_2
179 static void * iiI2NN(void *data)
180 {
181  if (currRing==NULL)
182  {
183  WerrorS("missing basering while converting int to Number");
184  return NULL;
185  }
186  number n=nInit((int)(long)data);
187  number2 nn=(number2)omAlloc(sizeof(*nn));
188  nn->cf=currRing->cf; nn->cf->ref++;
189  nn->n=n;
190  return (void *)nn;
191 }
192 static void * iiI2CP(void *data)
193 {
194  if (currRing==NULL)
195  {
196  WerrorS("missing basering while converting int to Poly");
197  return NULL;
198  }
199  poly n=pISet((int)(long)data);
200  poly2 nn=(poly2)omAlloc(sizeof(*nn));
201  nn->cf=currRing; nn->cf->ref++;
202  nn->n=n;
203  return (void *)nn;
204 }
205 #endif
206 
207 static void * iiBI2N(void *data)
208 {
209  if (currRing==NULL) return NULL;
211  if (nMap==NULL)
212  {
213  Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
214  return NULL;
215  }
216  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
217  n_Delete((number *)&data, coeffs_BIGINT);
218  return (void*)n;
219 }
220 
221 #ifdef SINGULAR_4_2
222 static void * iiBI2NN(void *data)
223 {
224  if (currRing==NULL)
225  {
226  WerrorS("missing basering while converting bigint to Number");
227  return NULL;
228  }
230  if (nMap==NULL)
231  {
232  Werror("no conversion from bigint to %s",currRing->cf->cfCoeffName(currRing->cf));
233  return NULL;
234  }
235  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
236  n_Delete((number *)&data, coeffs_BIGINT);
237  number2 nn=(number2)omAlloc(sizeof(*nn));
238  nn->cf=currRing->cf; nn->cf->ref++;
239  nn->n=n;
240  return (void*)nn;
241 }
242 static void * iiBI2CP(void *data)
243 {
244  if (currRing==NULL)
245  {
246  WerrorS("missing basering while converting bigint to Poly");
247  return NULL;
248  }
250  if (nMap==NULL)
251  {
252  Werror("no conversion from bigint to %s",currRing->cf->cfCoeffName(currRing->cf));
253  return NULL;
254  }
255  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
256  n_Delete((number *)&data, coeffs_BIGINT);
257  poly2 nn=(poly2)omAlloc(sizeof(*nn));
258  nn->cf=currRing; nn->cf->ref++;
259  nn->n=pNSet(n);
260  return (void*)nn;
261 }
262 static void * iiP2CP(void *data)
263 {
264  poly2 nn=(poly2)omAlloc(sizeof(*nn));
265  nn->cf=currRing; nn->cf->ref++;
266  nn->n=(poly)data;
267  return (void*)nn;
268 }
269 #endif
270 
271 #ifdef SINGULAR_4_2
272 static void * iiNN2N(void *data)
273 {
274  number2 d=(number2)data;
275  if ((currRing==NULL)
276  || (currRing->cf!=d->cf))
277  {
278  WerrorS("cannot convert: incompatible");
279  return NULL;
280  }
281  number n = n_Copy(d->n, d->cf);
282  n2Delete(d);
283  return (void*)n;
284 }
285 #endif
286 
287 #ifdef SINGULAR_4_2
288 static void * iiNN2P(void *data)
289 {
290  number2 d=(number2)data;
291  if ((currRing==NULL)
292  || (currRing->cf!=d->cf))
293  {
294  WerrorS("cannot convert: incompatible");
295  return NULL;
296  }
297  number n = n_Copy(d->n, d->cf);
298  n2Delete(d);
299  return (void*)p_NSet(n,currRing);
300 }
301 #endif
302 
303 static void * iiIm2Ma(void *data)
304 {
305  int i, j;
306  intvec *iv = (intvec *)data;
307  matrix m = mpNew(iv->rows(), iv->cols());
308 
309  for (i=iv->rows(); i>0; i--)
310  {
311  for (j=iv->cols(); j>0; j--)
312  {
313  MATELEM(m, i, j) = pISet(IMATELEM(*iv, i, j));
314  }
315  }
316  delete iv;
317  return (void *)m;
318 }
319 
320 static void * iiIm2Bim(void *data)
321 {
322  intvec *iv=(intvec*)data;
323  void *r=(void *)iv2bim(iv,coeffs_BIGINT);
324  delete iv;
325  return r;
326 }
327 
328 static void * iiN2P(void *data)
329 {
330  poly p=NULL;
331  if (!nIsZero((number)data))
332  {
333  p=pNSet((number)data);
334  }
335  //else
336  //{
337  // nDelete((number *)&data);
338  //}
339  return (void *)p;
340 }
341 
342 static void * iiN2Ma(void *data)
343 {
344  ideal I=idInit(1,1);
345  if (!nIsZero((number)data))
346  {
347  poly p=pNSet((number)data);
348  I->m[0]=p;
349  }
350  //else
351  //{
352  // nDelete((number *)&data);
353  //}
354  return (void *)I;
355 }
356 
357 static void * iiS2Link(void *data)
358 {
360  slInit(l, (char *) data);
361  omFree((ADDRESS)data);
362  return (void *)l;
363 }
364 
365 static void iiR2L_l(leftv out, leftv in)
366 {
367  int add_row_shift = 0;
368  intvec *weights=(intvec*)atGet(in,"isHomog",INTVEC_CMD);
369  if (weights!=NULL) add_row_shift=weights->min_in();
370 
371  syStrategy tmp=(syStrategy)in->CopyD();
372 
373  out->data=(void *)syConvRes(tmp,TRUE,add_row_shift);
374 }
375 
376 static void iiL2R(leftv out, leftv in)
377 {
378  //int add_row_shift = 0;
379  lists l=(lists)in->Data();
380  intvec *ww=NULL;
381  if (l->nr>=0) ww=(intvec *)atGet(&(l->m[0]),"isHomog",INTVEC_CMD);
382  out->data=(void *)syConvList(l);
383  if (ww!=NULL)
384  {
385  intvec *weights=ivCopy(ww);
386  atSet(out,omStrDup("isHomog"),weights,INTVEC_CMD);
387  }
388 }
389 
390 //
391 // automatic conversions:
392 //
393 #define IPCONV
394 #define D(A) A
395 #define NULL_VAL NULL
396 #include "Singular/table.h"
397 /*2
398 * try to convert 'input' of type 'inputType' to 'output' of type 'outputType'
399 * return FALSE on success
400 */
401 BOOLEAN iiConvert (int inputType, int outputType, int index, leftv input, leftv output,const struct sConvertTypes *dConvertTypes)
402 {
403  memset(output,0,sizeof(sleftv));
404  if ((inputType==outputType)
405  || (outputType==DEF_CMD)
406  || ((outputType==IDHDL)&&(input->rtyp==IDHDL)))
407  {
408  memcpy(output,input,sizeof(*output));
409  memset(input,0,sizeof(*input));
410  return FALSE;
411  }
412  else if (outputType==ANY_TYPE)
413  {
414  output->rtyp=ANY_TYPE;
415  output->data=(char *)(long)input->Typ();
416  /* the name of the object:*/
417  if (input->e==NULL)
418  {
419  if (input->rtyp==IDHDL)
420  /* preserve name: copy it */
421  output->name=omStrDup(IDID((idhdl)(input->data)));
422  else if (input->name!=NULL)
423  {
424  if (input->rtyp==ALIAS_CMD)
425  output->name=omStrDup(input->name);
426  else
427  {
428  output->name=input->name;
429  input->name=NULL;
430  }
431  }
432  else if ((input->rtyp==POLY_CMD) && (input->name==NULL))
433  {
434  if (input->data!=NULL)
435  {
436  int nr=pIsPurePower((poly)input->data);
437  if (nr!=0)
438  {
439  if (pGetExp((poly)input->data,nr)==1)
440  {
441  output->name=omStrDup(currRing->names[nr-1]);
442  }
443  else
444  {
445  char *tmp=(char *)omAlloc(4);
446  sprintf(tmp,"%c%d",*(currRing->names[nr-1]),
447  (int)pGetExp((poly)input->data,nr));
448  output->name=tmp;
449  }
450  }
451  else if(pIsConstant((poly)input->data))
452  {
453  StringSetS("");
454  number n=(pGetCoeff((poly)input->data));
455  n_Write(n, currRing->cf);
456  (pGetCoeff((poly)input->data))=n; // n_Write may have changed n
457  output->name=StringEndS();
458  }
459  }
460  }
461  else if ((input->rtyp==NUMBER_CMD) && (input->name==NULL))
462  {
463  StringSetS("");
464  number n=(number)input->data;
465  n_Write(n, currRing->cf);
466  input->data=(void*)n; // n_Write may have changed n
467  output->name=StringEndS();
468  }
469  else
470  {
471  /* no need to preserve name: use it */
472  output->name=input->name;
473  input->name=NULL;
474  }
475  }
476  output->next=input->next;
477  input->next=NULL;
478  if (!errorreported) input->CleanUp();
479  return errorreported;
480  }
481  if (index!=0) /* iiTestConvert does not returned 'failure' */
482  {
483  index--;
484 
485  if((dConvertTypes[index].i_typ==inputType)
486  &&(dConvertTypes[index].o_typ==outputType))
487  {
488  if(traceit&TRACE_CONV)
489  {
490  Print("automatic conversion %s -> %s\n",
491  Tok2Cmdname(inputType),Tok2Cmdname(outputType));
492  }
493  if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
494  return TRUE;
495  output->rtyp=outputType;
496  if (dConvertTypes[index].p!=NULL)
497  {
498  output->data=dConvertTypes[index].p(input->CopyD());
499  }
500  else
501  {
502  dConvertTypes[index].pl(output,input);
503  }
504  if ((output->data==NULL)
505  && ((outputType!=INT_CMD)
506  &&(outputType!=POLY_CMD)
507  &&(outputType!=VECTOR_CMD)
508  &&(outputType!=NUMBER_CMD)))
509  {
510  return TRUE;
511  }
512  if (errorreported) return TRUE;
513  output->next=input->next;
514  input->next=NULL;
515  if ((input->rtyp!=IDHDL) && (input->attribute!=NULL))
516  {
517  input->attribute->killAll(currRing);
518  input->attribute=NULL;
519  }
520  if (input->e!=NULL)
521  {
522  Subexpr h;
523  while (input->e!=NULL)
524  {
525  h=input->e->next;
526  omFreeBin((ADDRESS)input->e, sSubexpr_bin);
527  input->e=h;
528  }
529  }
530  //input->Init(); // seems that input (rtyp?) is still needed
531  return FALSE;
532  }
533  }
534  return TRUE;
535 }
536 
537 /*2
538 * try to convert 'inputType' in 'outputType'
539 * return 0 on failure, an index (<>0) on success
540 */
541 int iiTestConvert (int inputType, int outputType,const struct sConvertTypes *dConvertTypes)
542 {
543  if ((inputType==outputType)
544  || (outputType==DEF_CMD)
545  || (outputType==IDHDL)
546  || (outputType==ANY_TYPE))
547  {
548  return -1;
549  }
550  if (inputType==UNKNOWN) return 0;
551 
552  if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
553  return 0;
554  //if ((currRing==NULL) && (outputType==CNUMBER_CMD))
555  // return 0;
556 
557  // search the list
558  int i=0;
559  while (dConvertTypes[i].i_typ!=0)
560  {
561  if((dConvertTypes[i].i_typ==inputType)
562  &&(dConvertTypes[i].o_typ==outputType))
563  {
564  //Print("test convert %d to %d (%s -> %s):%d\n",inputType,outputType,
565  //Tok2Cmdname(inputType), Tok2Cmdname(outputType),i+1);
566  return i+1;
567  }
568  i++;
569  }
570  //Print("test convert %d to %d (%s -> %s):0, tested:%d\n",inputType,outputType,
571  // Tok2Cmdname(inputType), Tok2Cmdname(outputType),i);
572  return 0;
573 }
iiConvert
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
Definition: ipconv.cc:401
FALSE
#define FALSE
Definition: auxiliary.h:94
sConvertTypes::p
int p
Definition: gentable.cc:120
omalloc.h
matrix
ip_smatrix * matrix
Definition: matpol.h:31
sleftv::Data
void * Data()
Definition: subexpr.cc:1134
idVec2Ideal
static ideal idVec2Ideal(poly vec)
Definition: ideals.h:171
sConvertTypes
Definition: gentable.cc:116
pIsConstant
#define pIsConstant(p)
like above, except that Comp might be != 0
Definition: polys.h:225
sattr::killAll
void killAll(const ring r)
Definition: attrib.cc:188
ip_smatrix
Definition: matpol.h:14
pGetComp
#define pGetComp(p)
Component.
Definition: polys.h:37
iiBI2N
static void * iiBI2N(void *data)
Definition: ipconv.cc:207
iiN2P
static void * iiN2P(void *data)
Definition: ipconv.cc:328
j
int j
Definition: facHensel.cc:105
omFree
#define omFree(addr)
Definition: omAllocDecl.h:261
iiBI2V
static void * iiBI2V(void *data)
Definition: ipconv.cc:72
errorreported
short errorreported
Definition: feFopen.cc:23
id_Matrix2Module
ideal id_Matrix2Module(matrix mat, const ring R)
converts mat to module, destroys mat
Definition: simpleideals.cc:1167
iiL2R
static void iiL2R(leftv out, leftv in)
Definition: ipconv.cc:376
iiI2V
static void * iiI2V(void *data)
Definition: ipconv.cc:65
NUMBER_CMD
@ NUMBER_CMD
Definition: grammar.cc:287
MATELEM
#define MATELEM(mat, i, j)
Definition: matpol.h:30
syStrategy
ssyStrategy * syStrategy
Definition: syz.h:35
pGetExp
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
attrib.h
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
TRACE_CONV
#define TRACE_CONV
Definition: reporter.h:47
number2.h
iiP2Id
static void * iiP2Id(void *data)
Definition: ipconv.cc:116
pISet
#define pISet(i)
Definition: polys.h:298
polys.h
iiTestConvert
int iiTestConvert(int inputType, int outputType, const struct sConvertTypes *dConvertTypes)
Definition: ipconv.cc:541
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:263
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:456
DEF_CMD
@ DEF_CMD
Definition: tok.h:58
sleftv::attribute
attr attribute
Definition: subexpr.h:89
iiV2Ma
static void * iiV2Ma(void *data)
Definition: ipconv.cc:129
options.h
omAlloc0Bin
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
pDelete
#define pDelete(p_ptr)
Definition: polys.h:173
iiMa2Mo
static void * iiMa2Mo(void *data)
Definition: ipconv.cc:153
StringEndS
char * StringEndS()
Definition: reporter.cc:151
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:82
pSetComp
#define pSetComp(p, v)
Definition: polys.h:38
bigintmat.h
pSetCompP
#define pSetCompP(a, i)
Definition: polys.h:289
ANY_TYPE
#define ANY_TYPE
Definition: tok.h:30
sConvertTypes::o_typ
int o_typ
Definition: gentable.cc:119
iiIm2Bim
static void * iiIm2Bim(void *data)
Definition: ipconv.cc:320
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
BEGIN_RING
@ BEGIN_RING
Definition: grammar.cc:282
sConvertTypes::p
iiConvertProc p
Definition: ipconv.cc:39
sleftv::name
const char * name
Definition: subexpr.h:87
sSubexpr_bin
omBin sSubexpr_bin
Definition: subexpr.cc:45
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
iiR2L_l
static void iiR2L_l(leftv out, leftv in)
Definition: ipconv.cc:365
ivCopy
intvec * ivCopy(const intvec *o)
Definition: intvec.h:133
res
CanonicalForm res
Definition: facAbsFact.cc:64
INT_CMD
@ INT_CMD
Definition: tok.h:96
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:74
matpol.h
n_Write
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:592
intvec::min_in
int min_in()
Definition: intvec.h:121
syConvList
syStrategy syConvList(lists li)
Definition: ipshell.cc:3194
iiP2V
static void * iiP2V(void *data)
Definition: ipconv.cc:109
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
iiI2P
static void * iiI2P(void *data)
Definition: ipconv.cc:45
iiI2N
static void * iiI2N(void *data)
Definition: ipconv.cc:166
iiDummy
static void * iiDummy(void *data)
Definition: ipconv.cc:142
id_Module2Matrix
matrix id_Module2Matrix(ideal mod, const ring R)
Definition: simpleideals.cc:1201
h
static Poly * h
Definition: janet.cc:972
mod2.h
atSet
void atSet(idhdl root, char *name, void *data, int typ)
Definition: attrib.cc:152
intvec
Definition: intvec.h:17
sleftv::data
void * data
Definition: subexpr.h:88
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
iiS2Link
static void * iiS2Link(void *data)
Definition: ipconv.cc:357
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:539
END_RING
@ END_RING
Definition: grammar.cc:308
VECTOR_CMD
@ VECTOR_CMD
Definition: grammar.cc:290
pNSet
#define pNSet(n)
Definition: polys.h:299
pMaxComp
#define pMaxComp(p)
Definition: polys.h:285
intvec.h
iiMo2Ma
static void * iiMo2Ma(void *data)
Definition: ipconv.cc:147
subexpr.h
sleftv::CleanUp
void CleanUp(ring r=currRing)
Definition: subexpr.cc:328
ipconv.h
sleftv::e
Subexpr e
Definition: subexpr.h:105
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:36
slists
Definition: lists.h:22
UNKNOWN
#define UNKNOWN
Definition: tok.h:219
INTVEC_CMD
@ INTVEC_CMD
Definition: tok.h:101
nIsZero
#define nIsZero(n)
Definition: numbers.h:20
IMATELEM
#define IMATELEM(M, I, J)
Definition: intvec.h:85
coeffs_BIGINT
coeffs coeffs_BIGINT
Definition: ipid.cc:52
ring.h
idrec
Definition: idrec.h:34
sConvertTypes::i_typ
int i_typ
Definition: gentable.cc:118
ALIAS_CMD
@ ALIAS_CMD
Definition: tok.h:34
sConvertTypes::pl
iiConvertProcL pl
Definition: ipconv.cc:40
StringSetS
void StringSetS(const char *st)
Definition: reporter.cc:128
iiI2Id
static void * iiI2Id(void *data)
Definition: ipconv.cc:87
iiConvertProc
void *(* iiConvertProc)(void *data)
Definition: ipconv.cc:33
Print
#define Print
Definition: emacs.cc:80
sConvertTypes::pl
int pl
Definition: gentable.cc:121
intvec::cols
int cols() const
Definition: intvec.h:95
p_NSet
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1435
atGet
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition: attrib.cc:131
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:189
pIsPurePower
#define pIsPurePower(p)
Definition: polys.h:235
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:37
tok.h
IDHDL
#define IDHDL
Definition: tok.h:31
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:452
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
sleftv::Typ
int Typ()
Definition: subexpr.cc:992
m
int m
Definition: cfEzgcd.cc:121
MATCOLS
#define MATCOLS(i)
Definition: matpol.h:29
sleftv::rtyp
int rtyp
Definition: subexpr.h:91
syz.h
NULL
#define NULL
Definition: omList.c:10
sleftv::CopyD
void * CopyD(int t)
Definition: subexpr.cc:703
nCoeffName
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:977
lists
slists * lists
Definition: mpr_numeric.h:146
ideals.h
iiI2Iv
static void * iiI2Iv(void *data)
Definition: ipconv.cc:159
l
int l
Definition: cfEzgcd.cc:93
iiBI2Id
static void * iiBI2Id(void *data)
Definition: ipconv.cc:94
iiConvertProcL
void(* iiConvertProcL)(leftv out, leftv in)
Definition: ipconv.cc:34
intvec::rows
int rows() const
Definition: intvec.h:96
iiIm2Ma
static void * iiIm2Ma(void *data)
Definition: ipconv.cc:303
traceit
int traceit
Definition: febase.cc:42
dConvertTypes
const struct sConvertTypes dConvertTypes[]
Definition: table.h:1207
p
int p
Definition: cfModGcd.cc:4019
iiBI2P
static void * iiBI2P(void *data)
Definition: ipconv.cc:51
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
nInit
#define nInit(i)
Definition: numbers.h:25
POLY_CMD
@ POLY_CMD
Definition: grammar.cc:288
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:138
IDID
#define IDID(a)
Definition: ipid.h:117
iiN2Ma
static void * iiN2Ma(void *data)
Definition: ipconv.cc:342
ipshell.h
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:722
iiI2BI
static void * iiI2BI(void *data)
Definition: ipconv.cc:172
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:51
syConvRes
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
Definition: ipshell.cc:3122
MATROWS
#define MATROWS(i)
Definition: matpol.h:28
omFreeBin
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
iv2bim
bigintmat * iv2bim(intvec *b, const coeffs C)
Definition: bigintmat.cc:349
index
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
numbers.h
table.h
ipid.h
sleftv::next
leftv next
Definition: subexpr.h:86
ssyStrategy
Definition: syz.h:37
coeffs.h