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/ipconv.h>
31 
32 typedef void * (*iiConvertProc)(void * data);
33 typedef void (*iiConvertProcL)(leftv out,leftv in);
34 struct 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 
44 static void * iiI2P(void *data)
45 {
46  poly p=pISet((int)(long)data);
47  return (void *)p;
48 }
49 
50 static void * iiBI2P(void *data)
51 {
53  if (nMap==NULL)
54  {
55  Werror("no conversion from bigint to %s", nCoeffString(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 
64 static void * iiI2V(void *data)
65 {
66  poly p=pISet((int)(long)data);
67  if (p!=NULL) pSetComp(p,1);
68  return (void *)p;
69 }
70 
71 static void * iiBI2V(void *data)
72 {
74  if (nMap==NULL)
75  {
76  Werror("no conversion from bigint to %s", nCoeffString(currRing->cf));
77  return NULL;
78  }
79  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
80  n_Delete((number *)&data, coeffs_BIGINT);
81  poly p=p_NSet(n, currRing);
82  if (p!=NULL) pSetComp(p,1);
83  return (void *)p;
84 }
85 
86 static void * iiI2Id(void *data)
87 {
88  ideal I=idInit(1,1);
89  I->m[0]=pISet((int)(long)data);
90  return (void *)I;
91 }
92 
93 static void * iiBI2Id(void *data)
94 {
95  ideal I=idInit(1,1);
97  if (nMap==NULL)
98  {
99  Werror("no conversion from bigint to %s", nCoeffString(currRing->cf));
100  return NULL;
101  }
102  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
103  n_Delete((number *)&data,coeffs_BIGINT);
104  poly p=pNSet(n);
105  I->m[0]=p;
106  return (void *)I;
107 }
108 static void * iiP2V(void *data)
109 {
110  poly p=(poly)data;
111  if (p!=NULL) pSetCompP(p,1);
112  return (void *)p;
113 }
114 
115 static void * iiP2Id(void *data)
116 {
117  ideal I=idInit(1,1);
118 
119  if (data!=NULL)
120  {
121  poly p=(poly)data;
122  I->m[0]=p;
123  if (pGetComp(p)!=0) I->rank=pMaxComp(p);
124  }
125  return (void *)I;
126 }
127 
128 static void * iiV2Ma(void *data)
129 {
130  matrix m=(matrix)idVec2Ideal((poly)data);
131  int h=MATCOLS(m);
132  MATCOLS(m)=MATROWS(m);
133  MATROWS(m)=h;
134  m->rank=h;
135  pDelete((poly *)&data);
136  return (void *)m;
137 }
138 
139 static void * iiN2P(void *data);
140 
141 static void * iiDummy(void *data)
142 {
143  return data;
144 }
145 
146 static void * iiMo2Ma(void *data)
147 {
148  void *res=id_Module2Matrix((ideal)data,currRing);
149  return res;
150 }
151 
152 static void * iiMa2Mo(void *data)
153 {
154  void *res=id_Matrix2Module((matrix)data,currRing);
155  return res;
156 }
157 
158 static void * iiI2Iv(void *data)
159 {
160  int s=(int)(long)data;
161  intvec *iv=new intvec(s,s);
162  return (void *)iv;
163 }
164 
165 static void * iiI2N(void *data)
166 {
167  number n=nInit((int)(long)data);
168  return (void *)n;
169 }
170 
171 static void * iiI2BI(void *data)
172 {
173  number n=n_Init((int)(long)data, coeffs_BIGINT);
174  return (void *)n;
175 }
176 
177 static void * iiBI2N(void *data)
178 {
179  if (currRing==NULL) return NULL;
181  if (nMap==NULL)
182  {
183  Werror("no conversion from bigint to %s", nCoeffString(currRing->cf));
184  return NULL;
185  }
186  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
187  n_Delete((number *)&data, coeffs_BIGINT);
188  return (void*)n;
189 }
190 
191 static void * iiIm2Ma(void *data)
192 {
193  int i, j;
194  intvec *iv = (intvec *)data;
195  matrix m = mpNew(iv->rows(), iv->cols());
196 
197  for (i=iv->rows(); i>0; i--)
198  {
199  for (j=iv->cols(); j>0; j--)
200  {
201  MATELEM(m, i, j) = pISet(IMATELEM(*iv, i, j));
202  }
203  }
204  delete iv;
205  return (void *)m;
206 }
207 
208 static void * iiIm2Bim(void *data)
209 {
210  intvec *iv=(intvec*)data;
211  void *r=(void *)iv2bim(iv,coeffs_BIGINT);
212  delete iv;
213  return r;
214 }
215 
216 static void * iiN2P(void *data)
217 {
218  poly p=NULL;
219  if (!nIsZero((number)data))
220  {
221  p=pNSet((number)data);
222  }
223  //else
224  //{
225  // nDelete((number *)&data);
226  //}
227  return (void *)p;
228 }
229 
230 static void * iiN2Ma(void *data)
231 {
232  ideal I=idInit(1,1);
233  if (!nIsZero((number)data))
234  {
235  poly p=pNSet((number)data);
236  I->m[0]=p;
237  }
238  //else
239  //{
240  // nDelete((number *)&data);
241  //}
242  return (void *)I;
243 }
244 
245 static void * iiS2Link(void *data)
246 {
248  slInit(l, (char *) data);
249  omFree((ADDRESS)data);
250  return (void *)l;
251 }
252 
253 /*
254 static void * iiR2L(void * data)
255 {
256  syStrategy tmp=(syStrategy)data;
257  return (void *)syConvRes(tmp,TRUE);
258 }
259 */
260 static void iiR2L_l(leftv out, leftv in)
261 {
262  int add_row_shift = 0;
263  intvec *weights=(intvec*)atGet(in,"isHomog",INTVEC_CMD);
264  if (weights!=NULL) add_row_shift=weights->min_in();
265 
266  syStrategy tmp=(syStrategy)in->CopyD();
267 
268  out->data=(void *)syConvRes(tmp,TRUE,add_row_shift);
269 }
270 
271 static void * iiL2R(void * data)
272 {
273  return (void *)syConvList((lists)data,TRUE);
274 }
275 
276 //
277 // automatic conversions:
278 //
279 #define IPCONV
280 #define D(A) A
281 #define NULL_VAL NULL
282 #include <Singular/table.h>
283 /*2
284 * try to convert 'input' of type 'inputType' to 'output' of type 'outputType'
285 * return FALSE on success
286 */
287 BOOLEAN iiConvert (int inputType, int outputType, int index, leftv input, leftv output,struct sConvertTypes *dConvertTypes)
288 {
289  memset(output,0,sizeof(sleftv));
290  if ((inputType==outputType)
291  || (outputType==DEF_CMD)
292  || ((outputType==IDHDL)&&(input->rtyp==IDHDL)))
293  {
294  memcpy(output,input,sizeof(*output));
295  memset(input,0,sizeof(*input));
296  return FALSE;
297  }
298  else if (outputType==ANY_TYPE)
299  {
300  output->rtyp=ANY_TYPE;
301  output->data=(char *)(long)input->Typ();
302  /* the name of the object:*/
303  if (input->e==NULL)
304  {
305  if (input->rtyp==IDHDL)
306  /* preserve name: copy it */
307  output->name=omStrDup(IDID((idhdl)(input->data)));
308  else if (input->name!=NULL)
309  {
310  if (input->rtyp==ALIAS_CMD)
311  output->name=omStrDup(input->name);
312  else
313  {
314  output->name=input->name;
315  input->name=NULL;
316  }
317  }
318  else if ((input->rtyp==POLY_CMD) && (input->name==NULL))
319  {
320  if (input->data!=NULL)
321  {
322  int nr=pIsPurePower((poly)input->data);
323  if (nr!=0)
324  {
325  if (pGetExp((poly)input->data,nr)==1)
326  {
327  output->name=omStrDup(currRing->names[nr-1]);
328  }
329  else
330  {
331  char *tmp=(char *)omAlloc(4);
332  sprintf(tmp,"%c%d",*(currRing->names[nr-1]),
333  (int)pGetExp((poly)input->data,nr));
334  output->name=tmp;
335  }
336  }
337  else if(pIsConstant((poly)input->data))
338  {
339  StringSetS("");
340  number n=(pGetCoeff((poly)input->data));
341  n_Write(n, currRing->cf);
342  (pGetCoeff((poly)input->data))=n;
343  output->name=StringEndS();
344  }
345  }
346  }
347  else if ((input->rtyp==NUMBER_CMD) && (input->name==NULL))
348  {
349  StringSetS("");
350  number n=(number)input->data;
351  n_Write(n, currRing->cf);
352  input->data=(void*)n;
353  output->name=StringEndS();
354  }
355  else
356  {
357  /* no need to preserve name: use it */
358  output->name=input->name;
359  memset(input,0,sizeof(*input));
360  }
361  }
362  output->next=input->next;
363  input->next=NULL;
364  return FALSE;
365  }
366  if (index!=0) /* iiTestConvert does not returned 'failure' */
367  {
368  index--;
369 
370  if((dConvertTypes[index].i_typ==inputType)
371  &&(dConvertTypes[index].o_typ==outputType))
372  {
373  if(traceit&TRACE_CONV)
374  {
375  Print("automatic conversion %s -> %s\n",
376  Tok2Cmdname(inputType),Tok2Cmdname(outputType));
377  }
378  if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
379  return TRUE;
380  output->rtyp=outputType;
381  if (dConvertTypes[index].p!=NULL)
382  {
383  output->data=dConvertTypes[index].p(input->CopyD());
384  }
385  else
386  {
387  dConvertTypes[index].pl(output,input);
388  }
389  if ((output->data==NULL)
390  && ((outputType!=INT_CMD)
391  &&(outputType!=POLY_CMD)
392  &&(outputType!=VECTOR_CMD)
393  &&(outputType!=NUMBER_CMD)))
394  {
395  return TRUE;
396  }
397  output->next=input->next;
398  input->next=NULL;
399  //if (outputType==MATRIX_CMD) Print("convert %d -> matrix\n",inputType);
400  return FALSE;
401  }
402  }
403  return TRUE;
404 }
405 
406 /*2
407 * try to convert 'inputType' in 'outputType'
408 * return 0 on failure, an index (<>0) on success
409 */
410 int iiTestConvert (int inputType, int outputType,struct sConvertTypes *dConvertTypes)
411 {
412  if ((inputType==outputType)
413  || (outputType==DEF_CMD)
414  || (outputType==IDHDL)
415  || (outputType==ANY_TYPE))
416  {
417  return -1;
418  }
419 
420  if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
421  return 0;
422 
423  // search the list
424  int i=0;
425  while (dConvertTypes[i].i_typ!=0)
426  {
427  if((dConvertTypes[i].i_typ==inputType)
428  &&(dConvertTypes[i].o_typ==outputType))
429  {
430  //Print("test convert %d to %d (%s -> %s):%d\n",inputType,outputType,
431  //Tok2Cmdname(inputType), Tok2Cmdname(outputType),i+1);
432  return i+1;
433  }
434  i++;
435  }
436  //Print("test convert %d to %d (%s -> %s):0\n",inputType,outputType,
437  // Tok2Cmdname(inputType), Tok2Cmdname(outputType));
438  return 0;
439 }
static void * iiIm2Ma(void *data)
Definition: ipconv.cc:191
static void * iiP2Id(void *data)
Definition: ipconv.cc:115
static void * iiN2Ma(void *data)
Definition: ipconv.cc:230
#define pIsPurePower(p)
Definition: polys.h:219
const CanonicalForm int s
Definition: facAbsFact.cc:55
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define ANY_TYPE
Definition: tok.h:34
#define Print
Definition: emacs.cc:83
ideal idVec2Ideal(poly vec)
Definition: ideals.h:169
Definition: tok.h:85
#define pNSet(n)
Definition: polys.h:284
Subexpr e
Definition: subexpr.h:106
Definition: lists.h:22
#define pMaxComp(p)
Definition: polys.h:270
static void * iiBI2N(void *data)
Definition: ipconv.cc:177
#define IDID(a)
Definition: ipid.h:121
#define FALSE
Definition: auxiliary.h:140
int iiTestConvert(int inputType, int outputType, struct sConvertTypes *dConvertTypes)
Definition: ipconv.cc:410
Compatiblity layer for legacy polynomial operations (over currRing)
return P p
Definition: myNF.cc:203
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1448
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
Definition: ipshell.cc:2760
bigintmat * iv2bim(intvec *b, const coeffs C)
Definition: bigintmat.cc:349
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
static void * iiN2P(void *data)
Definition: ipconv.cc:216
#define TRACE_CONV
Definition: reporter.h:45
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static void * iiIm2Bim(void *data)
Definition: ipconv.cc:208
#define TRUE
Definition: auxiliary.h:144
void * ADDRESS
Definition: auxiliary.h:161
int min_in()
Definition: intvec.h:110
char * StringEndS()
Definition: reporter.cc:151
static void * iiMa2Mo(void *data)
Definition: ipconv.cc:152
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
int traceit
Definition: febase.cc:47
iiConvertProc p
Definition: ipconv.cc:38
coeffs coeffs_BIGINT
Definition: ipid.cc:53
int Typ()
Definition: subexpr.cc:955
#define omAlloc(size)
Definition: omAllocDecl.h:210
static void iiR2L_l(leftv out, leftv in)
Definition: ipconv.cc:260
#define pGetComp(p)
Component.
Definition: polys.h:37
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:35
void * data
Definition: subexpr.h:89
poly res
Definition: myNF.cc:322
static void * iiV2Ma(void *data)
Definition: ipconv.cc:128
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
const ring r
Definition: syzextra.cc:208
Coefficient rings, fields and other domains suitable for Singular polynomials.
Definition: intvec.h:16
static void * iiI2P(void *data)
Definition: ipconv.cc:44
int j
Definition: myNF.cc:70
Definition: tok.h:58
static void * iiL2R(void *data)
Definition: ipconv.cc:271
const char * name
Definition: subexpr.h:88
#define pSetCompP(a, i)
Definition: polys.h:274
#define omFree(addr)
Definition: omAllocDecl.h:261
void StringSetS(const char *st)
Definition: reporter.cc:128
static void * iiI2N(void *data)
Definition: ipconv.cc:165
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:72
iiConvertProcL pl
Definition: ipconv.cc:39
static FORCE_INLINE void n_Write(number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:592
ip_smatrix * matrix
static void * iiP2V(void *data)
Definition: ipconv.cc:108
#define pSetComp(p, v)
Definition: polys.h:38
int m
Definition: cfEzgcd.cc:119
#define pIsConstant(p)
like above, except that Comp might be != 0
Definition: polys.h:209
static void * iiS2Link(void *data)
Definition: ipconv.cc:245
int i
Definition: cfEzgcd.cc:123
matrix id_Module2Matrix(ideal mod, const ring R)
Definition: tok.h:88
static void * iiDummy(void *data)
Definition: ipconv.cc:141
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:720
leftv next
Definition: subexpr.h:87
struct sConvertTypes dConvertTypes[]
Definition: table.h:1117
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:597
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:48
Definition: tok.h:38
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition: attrib.cc:135
#define MATCOLS(i)
Definition: matpol.h:28
#define nIsZero(n)
Definition: numbers.h:19
#define NULL
Definition: omList.c:10
int cols() const
Definition: intvec.h:87
static void * iiMo2Ma(void *data)
Definition: ipconv.cc:146
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:128
static void * iiI2Id(void *data)
Definition: ipconv.cc:86
int rows() const
Definition: intvec.h:88
void *(* iiConvertProc)(void *data)
Definition: ipconv.cc:32
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, struct sConvertTypes *dConvertTypes)
Definition: ipconv.cc:287
static void * iiBI2Id(void *data)
Definition: ipconv.cc:93
#define pDelete(p_ptr)
Definition: polys.h:157
int rtyp
Definition: subexpr.h:92
static void * iiBI2P(void *data)
Definition: ipconv.cc:50
syStrategy syConvList(lists li, BOOLEAN toDel)
Definition: ipshell.cc:2836
void(* iiConvertProcL)(leftv out, leftv in)
Definition: ipconv.cc:33
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:456
#define MATROWS(i)
Definition: matpol.h:27
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar...
Definition: coeffs.h:963
polyrec * poly
Definition: hilb.h:10
#define pISet(i)
Definition: polys.h:283
#define nInit(i)
Definition: numbers.h:24
static Poly * h
Definition: janet.cc:978
int BOOLEAN
Definition: auxiliary.h:131
#define IMATELEM(M, I, J)
Definition: intvec.h:77
static void * iiBI2V(void *data)
Definition: ipconv.cc:71
static void * iiI2BI(void *data)
Definition: ipconv.cc:171
ideal id_Matrix2Module(matrix mat, const ring R)
static void * iiI2Iv(void *data)
Definition: ipconv.cc:158
static void * iiI2V(void *data)
Definition: ipconv.cc:64
void Werror(const char *fmt,...)
Definition: reporter.cc:199
void * CopyD(int t)
Definition: subexpr.cc:662
int l
Definition: cfEzgcd.cc:94
long rank
Definition: matpol.h:20
#define MATELEM(mat, i, j)
Definition: matpol.h:29
ssyStrategy * syStrategy
Definition: syz.h:35
#define omStrDup(s)
Definition: omAllocDecl.h:263