source: git/Singular/ipconv.cc @ c45b8f0

spielwiese
Last change on this file since c45b8f0 was 56c789, checked in by Hans Schoenemann <hannes@…>, 13 years ago
new table generation, p2 git-svn-id: file:///usr/local/Singular/svn/trunk@13459 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 8.5 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id$ */
5/*
6* ABSTRACT: automatic type conversions
7*/
8
9#include <kernel/mod2.h>
10#include <Singular/tok.h>
11#include <Singular/ipid.h>
12#include <kernel/intvec.h>
13#include <kernel/options.h>
14#include <omalloc/omalloc.h>
15#include <kernel/febase.h>
16#include <kernel/polys.h>
17#include <kernel/ideals.h>
18#include <Singular/subexpr.h>
19#include <kernel/numbers.h>
20#include <kernel/modulop.h>
21#include <kernel/longrat.h>
22#include <kernel/longalg.h>
23#ifdef HAVE_RINGS
24#include <kernel/rmodulon.h>
25#include <kernel/rmodulo2m.h>
26#include <kernel/rintegers.h>
27#endif
28#include <kernel/matpol.h>
29#include <Singular/silink.h>
30#include <kernel/syz.h>
31#include <Singular/attrib.h>
32#include <kernel/ring.h>
33#include <Singular/ipshell.h>
34#include <Singular/ipconv.h>
35
36typedef void *   (*iiConvertProc)(void * data);
37typedef void    (*iiConvertProcL)(leftv out,leftv in);
38struct sConvertTypes
39{
40  int i_typ;
41  int o_typ;
42  iiConvertProc p;
43  iiConvertProcL pl;
44};
45
46// all of these static conversion routines work destructive on their input
47
48static void * iiI2P(void *data)
49{
50  poly p=pISet((int)(long)data);
51  return (void *)p;
52}
53
54static void * iiBI2P(void *data)
55{
56  number n=nInit_bigint((number)data);
57  nlDelete((number *)&data,NULL);
58  poly p=pNSet(n);
59  return (void *)p;
60}
61
62static void * iiI2V(void *data)
63{
64  poly p=pISet((int)(long)data);
65  if (p!=NULL) pSetComp(p,1);
66  return (void *)p;
67}
68
69static void * iiBI2V(void *data)
70{
71  number n=nInit_bigint((number)data);
72  nlDelete((number *)&data,NULL);
73  poly p=pNSet(n);
74  if (p!=NULL) pSetComp(p,1);
75  return (void *)p;
76}
77
78static void * iiI2Id(void *data)
79{
80  ideal I=idInit(1,1);
81  I->m[0]=pISet((int)(long)data);
82  return (void *)I;
83}
84
85static void * iiBI2Id(void *data)
86{
87  ideal I=idInit(1,1);
88  number n=nInit_bigint((number)data);
89  nlDelete((number *)&data,NULL);
90  poly p=pNSet(n);
91  I->m[0]=p;
92  return (void *)I;
93}
94static void * iiP2V(void *data)
95{
96  poly p=(poly)data;
97  if (p!=NULL) pSetCompP(p,1);
98  return (void *)p;
99}
100
101static void * iiP2Id(void *data)
102{
103  ideal I=idInit(1,1);
104
105  I->m[0]=(poly)data;
106  if (data!=NULL)
107  {
108    poly p=(poly)data;
109    if (pGetComp(p)!=0) I->rank=pMaxComp(p);
110  }
111  return (void *)I;
112}
113
114static void * iiV2Ma(void *data)
115{
116  matrix m=(matrix)idVec2Ideal((poly)data);
117  int h=MATCOLS(m);
118  MATCOLS(m)=MATROWS(m);
119  MATROWS(m)=h;
120  m->rank=h;
121  pDelete((poly *)&data);
122  return (void *)m;
123}
124
125static void * iiN2P(void *data);
126
127static void * iiDummy(void *data)
128{
129  return data;
130}
131
132static void * iiMo2Ma(void *data)
133{
134  void *res=idModule2Matrix((ideal)data);
135  return res;
136}
137
138static void * iiMa2Mo(void *data)
139{
140  void *res=idMatrix2Module((matrix)data);
141  return res;
142}
143
144static void * iiI2Iv(void *data)
145{
146  int s=(int)(long)data;
147  intvec *iv=new intvec(s,s);
148  return (void *)iv;
149}
150
151static void * iiI2N(void *data)
152{
153  number n=nInit((int)(long)data);
154  return (void *)n;
155}
156
157static void * iiI2BI(void *data)
158{
159  number n=nlInit((int)(long)data, NULL /*dummy for nlInit*/);
160  return (void *)n;
161}
162
163static void * iiBI2N(void *data)
164{
165  if (currRing==NULL) return NULL;
166  // a bigint is really a number from char 0, with diffrent operations...
167  return (void*)nInit_bigint((number)data);
168}
169
170static void * iiIm2Ma(void *data)
171{
172  int i, j;
173  intvec *iv = (intvec *)data;
174  matrix m = mpNew(iv->rows(), iv->cols());
175
176  for (i=iv->rows(); i>0; i--)
177  {
178    for (j=iv->cols(); j>0; j--)
179    {
180      MATELEM(m, i, j) = pISet(IMATELEM(*iv, i, j));
181    }
182  }
183  delete iv;
184  return (void *)m;
185}
186
187static void * iiN2P(void *data)
188{
189  poly p=NULL;
190  if (!nIsZero((number)data))
191  {
192    p=pNSet((number)data);
193  }
194  //else
195  //{
196  //  nDelete((number *)&data);
197  //}
198  return (void *)p;
199}
200
201static void * iiN2Ma(void *data)
202{
203  ideal I=idInit(1,1);
204  if (!nIsZero((number)data))
205  {
206    poly p=pNSet((number)data);
207    I->m[0]=p;
208  }
209  //else
210  //{
211  //  nDelete((number *)&data);
212  //}
213  return (void *)I;
214}
215
216static void * iiS2Link(void *data)
217{
218  si_link l=(si_link)omAlloc0Bin(ip_link_bin);
219  slInit(l, (char *) data);
220  omFree((ADDRESS)data);
221  return (void *)l;
222}
223
224/*
225static void * iiR2L(void * data)
226{
227  syStrategy tmp=(syStrategy)data;
228  return  (void *)syConvRes(tmp,TRUE);
229}
230*/
231static void iiR2L_l(leftv out, leftv in)
232{
233  int add_row_shift = 0;
234  intvec *weights=(intvec*)atGet(in,"isHomog",INTVEC_CMD);
235  if (weights!=NULL)  add_row_shift=weights->min_in();
236
237  syStrategy tmp=(syStrategy)in->CopyD();
238  out->data=(void *)syConvRes(tmp,TRUE,add_row_shift);
239}
240
241static void * iiL2R(void * data)
242{
243  return (void *)syConvList((lists)data,TRUE);
244}
245
246//
247// automatic conversions:
248//
249#define IPCONV
250#define D(A) A
251#include <Singular/table.h>
252/*2
253* try to convert 'input' of type 'inputType' to 'output' of type 'outputType'
254* return FALSE on success
255*/
256BOOLEAN iiConvert (int inputType, int outputType, int index, leftv input, leftv output)
257{
258  memset(output,0,sizeof(sleftv));
259  if ((inputType==outputType)
260  || (outputType==DEF_CMD)
261  || ((outputType==IDHDL)&&(input->rtyp==IDHDL)))
262  {
263    memcpy(output,input,sizeof(*output));
264    memset(input,0,sizeof(*input));
265    return FALSE;
266  }
267  else if (outputType==ANY_TYPE)
268  {
269    output->rtyp=ANY_TYPE;
270    output->data=(char *)input->Typ();
271    /* the name of the object:*/
272    if (input->e==NULL)
273    {
274      if (input->rtyp==IDHDL)
275      /* preserve name: copy it */
276        output->name=omStrDup(IDID((idhdl)(input->data)));
277      else if (input->name!=NULL)
278      {
279        output->name=input->name;
280        input->name=NULL;
281      }
282      else if ((input->rtyp==POLY_CMD) && (input->name==NULL))
283      {
284        if (input->data!=NULL)
285        {
286          int nr=pIsPurePower((poly)input->data);
287          if (nr!=0)
288          {
289            if (pGetExp((poly)input->data,nr)==1)
290            {
291              output->name=omStrDup(currRing->names[nr-1]);
292            }
293            else
294            {
295              char *tmp=(char *)omAlloc(4);
296              sprintf(tmp,"%c%d",*(currRing->names[nr-1]),
297                (int)pGetExp((poly)input->data,nr));
298              output->name=tmp;
299            }
300          }
301          else if(pIsConstant((poly)input->data))
302          {
303            output->name=nName(pGetCoeff((poly)input->data));
304          }
305#ifdef TEST
306          else
307          {
308            WerrorS("wrong name, should not happen");
309            output->name=omStrDup("?");
310          }
311#endif
312        }
313      }
314      else if ((input->rtyp==NUMBER_CMD) && (input->name==NULL))
315      {
316        output->name=nName((number)input->data);
317      }
318      else
319      {
320        /* no need to preserve name: use it */
321        output->name=input->name;
322        memset(input,0,sizeof(*input));
323      }
324    }
325    output->next=input->next;
326    input->next=NULL;
327    return FALSE;
328  }
329  if (index!=0) /* iiTestConvert does not returned 'failure' */
330  {
331    index--;
332
333    if((dConvertTypes[index].i_typ==inputType)
334    &&(dConvertTypes[index].o_typ==outputType))
335    {
336      if(TEST_V_ALLWARN)
337      {
338        Print("automatic  conversion %s -> %s\n",
339        Tok2Cmdname(inputType),Tok2Cmdname(outputType));
340      }
341      if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
342        return TRUE;
343      output->rtyp=outputType;
344      if (dConvertTypes[index].p!=NULL)
345      {
346        output->data=dConvertTypes[index].p(input->CopyD());
347      }
348      else
349      {
350        dConvertTypes[index].pl(output,input);
351      }
352      if ((output->data==NULL)
353      && ((outputType!=INT_CMD)
354        &&(outputType!=POLY_CMD)
355        &&(outputType!=VECTOR_CMD)
356        &&(outputType!=NUMBER_CMD)))
357      {
358        return TRUE;
359      }
360      output->next=input->next;
361      input->next=NULL;
362  //if (outputType==MATRIX_CMD) Print("convert %d -> matrix\n",inputType);
363      return FALSE;
364    }
365  }
366  return TRUE;
367}
368
369/*2
370* try to convert 'inputType' in 'outputType'
371* return 0 on failure, an index (<>0) on success
372*/
373int iiTestConvert (int inputType, int outputType)
374{
375  if ((inputType==outputType)
376  || (outputType==DEF_CMD)
377  || (outputType==IDHDL)
378  || (outputType==ANY_TYPE))
379  {
380    return -1;
381  }
382
383  if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
384    return 0;
385
386  // search the list
387  int i=0;
388  while (dConvertTypes[i].i_typ!=0)
389  {
390    if((dConvertTypes[i].i_typ==inputType)
391    &&(dConvertTypes[i].o_typ==outputType))
392    {
393      //Print("test convert %d to %d (%s -> %s):%d\n",inputType,outputType,
394      //Tok2Cmdname(inputType), Tok2Cmdname(outputType),i+1);
395      return i+1;
396    }
397    i++;
398  }
399  //Print("test convert %d to %d (%s -> %s):0\n",inputType,outputType,
400  // Tok2Cmdname(inputType), Tok2Cmdname(outputType));
401  return 0;
402}
Note: See TracBrowser for help on using the repository browser.