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);
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 }
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{
66 sBucket_pt b=(sBucket_pt)in->CopyD();
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 }
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;
97 int l=aa->rows();
99 for(int i=0;i<l;i++)
100 {
102 n_Delete(&BIMATELEM((*bim),1,i+1), coeffs_BIGINT);
103 BIMATELEM((*bim),1,i+1)=tp;
104 }
105 return (void *)bim;
106}
107
108static void * iiI2Id(void *data)
109{
110 ideal I=idInit(1,1);
111 I->m[0]=pISet((int)(long)data);
112 return (void *)I;
113}
114
115static void * iiBI2Id(void *data)
116{
117 ideal I=idInit(1,1);
119 if (nMap==NULL)
120 {
121 Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
122 return NULL;
123 }
125 n_Delete((number *)&data,coeffs_BIGINT);
126 poly p=pNSet(n);
127 I->m[0]=p;
128 return (void *)I;
129}
130static void * iiBu2V(void *data)
131{
132 poly p=NULL;
133 if (data!=NULL)
134 {
135 sBucket_pt b=(sBucket_pt)data;
136 int l;
138 if (p!=NULL) pSetCompP(p,1);
139 }
140 return (void *)p;
141}
142
143static void * iiP2V(void *data)
144{
145 poly p=(poly)data;
146 if (p!=NULL) pSetCompP(p,1);
147 return (void *)p;
148}
149
150static void * iiBu2Id(void *data)
151{
152 ideal I=idInit(1,1);
153
154 if (data!=NULL)
155 {
156 sBucket_pt b=(sBucket_pt)data;
157 poly p; int l;
159 I->m[0]=p;
160 }
161 return (void *)I;
162}
163
164static void * iiP2Id(void *data)
165{
166 ideal I=idInit(1,1);
167
168 if (data!=NULL)
169 {
170 poly p=(poly)data;
171 I->m[0]=p;
172 if (pGetComp(p)!=0) I->rank=pMaxComp(p);
173 }
174 return (void *)I;
175}
176
177static void * iiV2Ma(void *data)
178{
179 matrix m=(matrix)idVec2Ideal((poly)data);
180 int h=MATCOLS(m);
181 MATCOLS(m)=MATROWS(m);
182 MATROWS(m)=h;
183 m->rank=h;
184 pDelete((poly *)&data);
185 return (void *)m;
186}
187
188static void * iiN2P(void *data);
189
190static void * iiDummy(void *data)
191{
192 return data;
193}
194
195static void * iiMo2Ma(void *data)
196{
197 void *res=id_Module2Matrix((ideal)data,currRing);
198 return res;
199}
200
201static void * iiMa2Mo(void *data)
202{
203 void *res=id_Matrix2Module((matrix)data,currRing);
204 return res;
205}
206
207static void * iiI2Iv(void *data)
208{
209 int s=(int)(long)data;
210 intvec *iv=new intvec(s,s);
211 return (void *)iv;
212}
213
214static void * iiI2N(void *data)
215{
216 number n=nInit((int)(long)data);
217 return (void *)n;
218}
219
220static void * iiI2BI(void *data)
221{
222 number n=n_Init((int)(long)data, coeffs_BIGINT);
223 return (void *)n;
224}
225
226static void * iiI2BIV(void *data)
227{
228 number n=n_Init((int)(long)data, coeffs_BIGINT);
230 n_Delete(&((*b)[0]),coeffs_BIGINT);
231 (*b)[0]=n;
232 return (void *)b;
233}
234#ifdef SINGULAR_4_2
235static void * iiI2NN(void *data)
236{
237 if (currRing==NULL)
238 {
239 WerrorS("missing basering while converting int to Number");
240 return NULL;
241 }
242 number n=nInit((int)(long)data);
243 number2 nn=(number2)omAlloc(sizeof(*nn));
244 nn->cf=currRing->cf; nn->cf->ref++;
245 nn->n=n;
246 return (void *)nn;
247}
248static void * iiI2CP(void *data)
249{
250 if (currRing==NULL)
251 {
252 WerrorS("missing basering while converting int to Poly");
253 return NULL;
254 }
255 poly n=pISet((int)(long)data);
256 poly2 nn=(poly2)omAlloc(sizeof(*nn));
257 nn->cf=currRing; nn->cf->ref++;
258 nn->n=n;
259 return (void *)nn;
260}
261#endif
262
263static void * iiBI2N(void *data)
264{
265 if (currRing==NULL) return NULL;
267 if (nMap==NULL)
268 {
269 Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
270 return NULL;
271 }
273 n_Delete((number *)&data, coeffs_BIGINT);
274 return (void*)n;
275}
276
277#ifdef SINGULAR_4_2
278static void * iiBI2NN(void *data)
279{
280 if (currRing==NULL)
281 {
282 WerrorS("missing basering while converting bigint to Number");
283 return NULL;
284 }
286 if (nMap==NULL)
287 {
288 Werror("no conversion from bigint to %s",currRing->cf->cfCoeffName(currRing->cf));
289 return NULL;
290 }
292 n_Delete((number *)&data, coeffs_BIGINT);
293 number2 nn=(number2)omAlloc(sizeof(*nn));
294 nn->cf=currRing->cf; nn->cf->ref++;
295 nn->n=n;
296 return (void*)nn;
297}
298static void * iiBI2CP(void *data)
299{
300 if (currRing==NULL)
301 {
302 WerrorS("missing basering while converting bigint to Poly");
303 return NULL;
304 }
306 if (nMap==NULL)
307 {
308 Werror("no conversion from bigint to %s",currRing->cf->cfCoeffName(currRing->cf));
309 return NULL;
310 }
312 n_Delete((number *)&data, coeffs_BIGINT);
313 poly2 nn=(poly2)omAlloc(sizeof(*nn));
314 nn->cf=currRing; nn->cf->ref++;
315 nn->n=pNSet(n);
316 return (void*)nn;
317}
318static void * iiP2CP(void *data)
319{
320 poly2 nn=(poly2)omAlloc(sizeof(*nn));
321 nn->cf=currRing; nn->cf->ref++;
322 nn->n=(poly)data;
323 return (void*)nn;
324}
325#endif
326
327#ifdef SINGULAR_4_2
328static void * iiNN2N(void *data)
329{
330 number2 d=(number2)data;
331 if ((currRing==NULL)
332 || (currRing->cf!=d->cf))
333 {
334 WerrorS("cannot convert: incompatible");
335 return NULL;
336 }
337 number n = n_Copy(d->n, d->cf);
338 n2Delete(d);
339 return (void*)n;
340}
341#endif
342
343#ifdef SINGULAR_4_2
344static void * iiNN2P(void *data)
345{
346 number2 d=(number2)data;
347 if ((currRing==NULL)
348 || (currRing->cf!=d->cf))
349 {
350 WerrorS("cannot convert: incompatible");
351 return NULL;
352 }
353 number n = n_Copy(d->n, d->cf);
354 n2Delete(d);
355 return (void*)p_NSet(n,currRing);
356}
357#endif
358
359static void * iiIm2Ma(void *data)
360{
361 int i, j;
362 intvec *iv = (intvec *)data;
363 matrix m = mpNew(iv->rows(), iv->cols());
364
365 for (i=iv->rows(); i>0; i--)
366 {
367 for (j=iv->cols(); j>0; j--)
368 {
369 MATELEM(m, i, j) = pISet(IMATELEM(*iv, i, j));
370 }
371 }
372 delete iv;
373 return (void *)m;
374}
375
376static void * iiIm2Bim(void *data)
377{
378 intvec *iv=(intvec*)data;
379 void *r=(void *)iv2bim(iv,coeffs_BIGINT);
380 delete iv;
381 return r;
382}
383
384static void * iiN2P(void *data)
385{
386 poly p=NULL;
387 if (!nIsZero((number)data))
388 {
389 p=pNSet((number)data);
390 }
391 //else
392 //{
393 // nDelete((number *)&data);
394 //}
395 return (void *)p;
396}
397
398static void * iiN2Ma(void *data)
399{
400 ideal I=idInit(1,1);
401 if (!nIsZero((number)data))
402 {
403 poly p=pNSet((number)data);
404 I->m[0]=p;
405 }
406 //else
407 //{
408 // nDelete((number *)&data);
409 //}
410 return (void *)I;
411}
412
413static void * iiS2Link(void *data)
414{
416 slInit(l, (char *) data);
417 omFree((ADDRESS)data);
418 return (void *)l;
419}
420
421static void iiR2L_l(leftv out, leftv in)
422{
423 int add_row_shift = 0;
424 intvec *weights=(intvec*)atGet(in,"isHomog",INTVEC_CMD);
425 if (weights!=NULL) add_row_shift=weights->min_in();
426
427 syStrategy tmp=(syStrategy)in->CopyD();
428
429 out->data=(void *)syConvRes(tmp,TRUE,add_row_shift);
430}
431
432static void iiL2R(leftv out, leftv in)
433{
434 //int add_row_shift = 0;
435 lists l=(lists)in->Data();
436 intvec *ww=NULL;
437 if (l->nr>=0) ww=(intvec *)atGet(&(l->m[0]),"isHomog",INTVEC_CMD);
438 out->data=(void *)syConvList(l);
439 if (ww!=NULL)
440 {
441 intvec *weights=ivCopy(ww);
442 atSet(out,omStrDup("isHomog"),weights,INTVEC_CMD);
443 }
444}
445
446//
447// automatic conversions:
448//
449#define IPCONV
450#define D(A) A
451#define NULL_VAL NULL
452#include "Singular/table.h"
453/*2
454* try to convert 'input' of type 'inputType' to 'output' of type 'outputType'
455* return FALSE on success
456*/
458{
459 output->Init();
460 if ((inputType==outputType)
461 || (outputType==DEF_CMD)
462 || ((outputType==IDHDL)&&(input->rtyp==IDHDL)))
463 {
464 memcpy(output,input,sizeof(*output));
465 input->Init();
466 return FALSE;
467 }
468 else if (outputType==ANY_TYPE)
469 {
470 output->rtyp=ANY_TYPE;
471 output->data=(char *)(long)input->Typ();
472 /* the name of the object:*/
473 if (input->e==NULL)
474 {
475 if (input->rtyp==IDHDL)
476 /* preserve name: copy it */
477 output->name=omStrDup(IDID((idhdl)(input->data)));
478 else if (input->name!=NULL)
479 {
480 if (input->rtyp==ALIAS_CMD)
481 output->name=omStrDup(input->name);
482 else
483 {
484 output->name=input->name;
485 input->name=NULL;
486 }
487 }
488 else if ((input->rtyp==POLY_CMD) && (input->name==NULL))
489 {
490 if (input->data!=NULL)
491 {
492 int nr=pIsPurePower((poly)input->data);
493 if (nr!=0)
494 {
495 if (pGetExp((poly)input->data,nr)==1)
496 {
497 output->name=omStrDup(currRing->names[nr-1]);
498 }
499 else
500 {
501 char *tmp=(char *)omAlloc(8);
502 snprintf(tmp,8,"%c%d",*(currRing->names[nr-1]),
503 (int)pGetExp((poly)input->data,nr));
504 output->name=tmp;
505 }
506 }
507 else if(pIsConstant((poly)input->data))
508 {
509 StringSetS("");
510 number n=(pGetCoeff((poly)input->data));
511 n_Write(n, currRing->cf);
512 (pGetCoeff((poly)input->data))=n; // n_Write may have changed n
513 output->name=StringEndS();
514 }
515 }
516 }
517 else if ((input->rtyp==NUMBER_CMD) && (input->name==NULL))
518 {
519 StringSetS("");
520 number n=(number)input->data;
521 n_Write(n, currRing->cf);
522 input->data=(void*)n; // n_Write may have changed n
523 output->name=StringEndS();
524 }
525 else
526 {
527 /* no need to preserve name: use it */
528 output->name=input->name;
529 input->name=NULL;
530 }
531 }
532 output->next=input->next;
533 input->next=NULL;
534 if (!errorreported) input->CleanUp();
535 return errorreported;
536 }
537 if (index!=0) /* iiTestConvert does not returned 'failure' */
538 {
539 index--;
540
541 if((dConvertTypes[index].i_typ==inputType)
542 &&(dConvertTypes[index].o_typ==outputType))
543 {
545 {
546 Print("automatic conversion %s -> %s\n",
548 }
550 return TRUE;
551 output->rtyp=outputType;
553 {
554 output->data=dConvertTypes[index].p(input->CopyD());
555 }
556 else
557 {
559 }
560 if ((output->data==NULL)
561 && ((outputType!=INT_CMD)
565 {
566 return TRUE;
567 }
568 if (errorreported) return TRUE;
569 output->next=input->next;
570 input->next=NULL;
571 if ((input->rtyp!=IDHDL) && (input->attribute!=NULL))
572 {
573 input->attribute->killAll(currRing);
574 input->attribute=NULL;
575 }
576 if (input->e!=NULL)
577 {
578 Subexpr h;
579 while (input->e!=NULL)
580 {
581 h=input->e->next;
583 input->e=h;
584 }
585 }
586 //input->Init(); // seems that input (rtyp?) is still needed
587 return FALSE;
588 }
589 }
590 return TRUE;
591}
592
593/*2
594* try to convert 'inputType' in 'outputType'
595* return 0 on failure, an index (<>0) on success
596*/
598{
599 if ((inputType==outputType)
600 || (outputType==DEF_CMD)
601 || (outputType==IDHDL)
602 || (outputType==ANY_TYPE))
603 {
604 return -1;
605 }
606 if (inputType==UNKNOWN) return 0;
607
609 return 0;
610 //if ((currRing==NULL) && (outputType==CNUMBER_CMD))
611 // return 0;
612
613 // search the list
614 int i=0;
615 while (dConvertTypes[i].i_typ!=0)
616 {
617 if((dConvertTypes[i].i_typ==inputType)
618 &&(dConvertTypes[i].o_typ==outputType))
619 {
620 //Print("test convert %d to %d (%s -> %s):%d\n",inputType,outputType,
621 //Tok2Cmdname(inputType), Tok2Cmdname(outputType),i+1);
622 return i+1;
623 }
624 i++;
625 }
626 //Print("test convert %d to %d (%s -> %s):0, tested:%d\n",inputType,outputType,
627 // Tok2Cmdname(inputType), Tok2Cmdname(outputType),i);
628 return 0;
629}
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:87
#define TRUE
Definition auxiliary.h:100
#define FALSE
Definition auxiliary.h:96
bigintmat * iv2bim(intvec *b, const coeffs C)
Definition bigintmat.cc:347
#define BIMATELEM(M, I, J)
Definition bigintmat.h:133
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
Definition idrec.h:35
int min_in()
Definition intvec.h:121
int cols() const
Definition intvec.h:95
int rows() const
Definition intvec.h:96
Class used for (list of) interpreter objects.
Definition subexpr.h:83
Definition lists.h:24
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:956
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:135
@ 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:172
intvec * ivCopy(const intvec *o)
Definition intvec.h:145
#define IMATELEM(M, I, J)
Definition intvec.h:85
iiConvertProc p
Definition ipconv.cc:38
static void * iiBI2V(void *data)
Definition ipconv.cc:79
static void * iiP2V(void *data)
Definition ipconv.cc:143
static void iiL2R(leftv out, leftv in)
Definition ipconv.cc:432
static void * iiIm2Ma(void *data)
Definition ipconv.cc:359
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:398
static void * iiN2P(void *data)
Definition ipconv.cc:384
static void * iiV2Ma(void *data)
Definition ipconv.cc:177
static void * iiIV2BIV(void *data)
Definition ipconv.cc:94
static void * iiDummy(void *data)
Definition ipconv.cc:190
void *(* iiConvertProc)(void *data)
Definition ipconv.cc:32
static void * iiI2BI(void *data)
Definition ipconv.cc:220
void(* iiConvertProcL)(leftv out, leftv in)
Definition ipconv.cc:33
static void * iiP2Id(void *data)
Definition ipconv.cc:164
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
Definition ipconv.cc:457
static void * iiMa2Mo(void *data)
Definition ipconv.cc:201
static void * iiI2Id(void *data)
Definition ipconv.cc:108
static void * iiS2Link(void *data)
Definition ipconv.cc:413
static void * iiI2Iv(void *data)
Definition ipconv.cc:207
static void * iiI2N(void *data)
Definition ipconv.cc:214
static void * iiMo2Ma(void *data)
Definition ipconv.cc:195
static void iiR2L_l(leftv out, leftv in)
Definition ipconv.cc:421
static void * iiI2V(void *data)
Definition ipconv.cc:72
int iiTestConvert(int inputType, int outputType, const struct sConvertTypes *dConvertTypes)
Definition ipconv.cc:597
static void * iiIm2Bim(void *data)
Definition ipconv.cc:376
static void * iiI2BIV(void *data)
Definition ipconv.cc:226
static void * iiBu2Id(void *data)
Definition ipconv.cc:150
static void * iiBu2V(void *data)
Definition ipconv.cc:130
static void * iiBI2Id(void *data)
Definition ipconv.cc:115
static void * iiI2P(void *data)
Definition ipconv.cc:44
iiConvertProcL pl
Definition ipconv.cc:39
static void * iiBI2N(void *data)
Definition ipconv.cc:263
const struct sConvertTypes dConvertTypes[]
Definition table.h:1320
VAR coeffs coeffs_BIGINT
Definition ipid.cc:50
#define IDID(a)
Definition ipid.h:122
syStrategy syConvList(lists li)
Definition ipshell.cc:3250
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
Definition ipshell.cc:3178
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 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:186
#define pIsConstant(p)
like above, except that Comp must be 0
Definition polys.h:238
#define pSetCompP(a, i)
Definition polys.h:303
#define pGetComp(p)
Component.
Definition polys.h:37
#define pNSet(n)
Definition polys.h:313
#define pMaxComp(p)
Definition polys.h:299
#define pSetComp(p, v)
Definition polys.h:38
#define pGetExp(p, i)
Exponent.
Definition polys.h:41
#define pIsPurePower(p)
Definition polys.h:248
#define pISet(i)
Definition polys.h:312
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
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
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