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