Data Structures | Macros | Typedefs | Functions
ipconv.cc File Reference
#include <kernel/mod2.h>
#include <Singular/tok.h>
#include <Singular/ipid.h>
#include <misc/intvec.h>
#include <misc/options.h>
#include <omalloc/omalloc.h>
#include <kernel/polys.h>
#include <kernel/ideals.h>
#include <Singular/subexpr.h>
#include <coeffs/numbers.h>
#include <coeffs/coeffs.h>
#include <coeffs/bigintmat.h>
#include <polys/matpol.h>
#include <Singular/links/silink.h>
#include <kernel/GBEngine/syz.h>
#include <Singular/attrib.h>
#include <polys/monomials/ring.h>
#include <Singular/ipshell.h>
#include <Singular/number2.h>
#include <Singular/ipconv.h>
#include <Singular/table.h>

Go to the source code of this file.

Data Structures

struct  sConvertTypes
 

Macros

#define IPCONV
 
#define D(A)   A
 
#define NULL_VAL   NULL
 

Typedefs

typedef void *(* iiConvertProc) (void *data)
 
typedef void(* iiConvertProcL) (leftv out, leftv in)
 

Functions

static void * iiI2P (void *data)
 
static void * iiBI2P (void *data)
 
static void * iiI2V (void *data)
 
static void * iiBI2V (void *data)
 
static void * iiI2Id (void *data)
 
static void * iiBI2Id (void *data)
 
static void * iiP2V (void *data)
 
static void * iiP2Id (void *data)
 
static void * iiV2Ma (void *data)
 
static void * iiN2P (void *data)
 
static void * iiDummy (void *data)
 
static void * iiMo2Ma (void *data)
 
static void * iiMa2Mo (void *data)
 
static void * iiI2Iv (void *data)
 
static void * iiI2N (void *data)
 
static void * iiI2BI (void *data)
 
static void * iiI2NN (void *data)
 
static void * iiBI2N (void *data)
 
static void * iiBI2NN (void *data)
 
static void * iiNN2N (void *data)
 
static void * iiNN2P (void *data)
 
static void * iiIm2Ma (void *data)
 
static void * iiIm2Bim (void *data)
 
static void * iiN2Ma (void *data)
 
static void * iiS2Link (void *data)
 
static void iiR2L_l (leftv out, leftv in)
 
static void iiL2R (leftv out, leftv in)
 
BOOLEAN iiConvert (int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
 
int iiTestConvert (int inputType, int outputType, const struct sConvertTypes *dConvertTypes)
 

Data Structure Documentation

§ sConvertTypes

struct sConvertTypes

Definition at line 106 of file gentable.cc.

Data Fields
int i_typ
int o_typ
iiConvertProc p
int p
iiConvertProcL pl
int pl

Macro Definition Documentation

§ D

#define D (   A)    A

Definition at line 353 of file ipconv.cc.

§ IPCONV

#define IPCONV

Definition at line 352 of file ipconv.cc.

§ NULL_VAL

#define NULL_VAL   NULL

Definition at line 354 of file ipconv.cc.

Typedef Documentation

§ iiConvertProc

typedef void*(* iiConvertProc) (void *data)

Definition at line 33 of file ipconv.cc.

§ iiConvertProcL

typedef void(* iiConvertProcL) (leftv out, leftv in)

Definition at line 34 of file ipconv.cc.

Function Documentation

§ iiBI2Id()

static void* iiBI2Id ( void *  data)
static

Definition at line 94 of file ipconv.cc.

95 {
96  ideal I=idInit(1,1);
98  if (nMap==NULL)
99  {
100  Werror("no conversion from bigint to %s", nCoeffString(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 }
#define pNSet(n)
Definition: polys.h:296
return P p
Definition: myNF.cc:203
coeffs coeffs_BIGINT
Definition: ipid.cc:54
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
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:725
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
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:973
polyrec * poly
Definition: hilb.h:10
void Werror(const char *fmt,...)
Definition: reporter.cc:189

§ iiBI2N()

static void* iiBI2N ( void *  data)
static

Definition at line 194 of file ipconv.cc.

195 {
196  if (currRing==NULL) return NULL;
198  if (nMap==NULL)
199  {
200  Werror("no conversion from bigint to %s", nCoeffString(currRing->cf));
201  return NULL;
202  }
203  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
204  n_Delete((number *)&data, coeffs_BIGINT);
205  return (void*)n;
206 }
coeffs coeffs_BIGINT
Definition: ipid.cc:54
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
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:725
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
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:973
void Werror(const char *fmt,...)
Definition: reporter.cc:189

§ iiBI2NN()

static void* iiBI2NN ( void *  data)
static

Definition at line 209 of file ipconv.cc.

210 {
211  if (currRing==NULL)
212  {
213  WerrorS("missing basering while converting bigint to Number");
214  return NULL;
215  }
217  if (nMap==NULL)
218  {
219  Werror("no conversion from bigint to %s",currRing->cf->cfCoeffString(currRing->cf));
220  return NULL;
221  }
222  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
223  n_Delete((number *)&data, coeffs_BIGINT);
224  number2 nn=(number2)omAlloc(sizeof*nn);
225  nn->cf=currRing->cf; nn->cf->ref++;
226  return (void*)nn;
227 }
void WerrorS(const char *s)
Definition: feFopen.cc:24
coeffs coeffs_BIGINT
Definition: ipid.cc:54
#define omAlloc(size)
Definition: omAllocDecl.h:210
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
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:725
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
void Werror(const char *fmt,...)
Definition: reporter.cc:189

§ iiBI2P()

static void* iiBI2P ( void *  data)
static

Definition at line 51 of file ipconv.cc.

52 {
54  if (nMap==NULL)
55  {
56  Werror("no conversion from bigint to %s", nCoeffString(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 }
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:1443
coeffs coeffs_BIGINT
Definition: ipid.cc:54
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
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:725
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
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:973
polyrec * poly
Definition: hilb.h:10
void Werror(const char *fmt,...)
Definition: reporter.cc:189

§ iiBI2V()

static void* iiBI2V ( void *  data)
static

Definition at line 72 of file ipconv.cc.

73 {
75  if (nMap==NULL)
76  {
77  Werror("no conversion from bigint to %s", nCoeffString(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 }
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:1443
coeffs coeffs_BIGINT
Definition: ipid.cc:54
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
#define pSetComp(p, v)
Definition: polys.h:38
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:725
#define NULL
Definition: omList.c:10
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:459
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:973
polyrec * poly
Definition: hilb.h:10
void Werror(const char *fmt,...)
Definition: reporter.cc:189

§ iiConvert()

BOOLEAN iiConvert ( int  inputType,
int  outputType,
int  index,
leftv  input,
leftv  output,
const struct sConvertTypes dConvertTypes 
)

Definition at line 360 of file ipconv.cc.

361 {
362  memset(output,0,sizeof(sleftv));
363  if ((inputType==outputType)
364  || (outputType==DEF_CMD)
365  || ((outputType==IDHDL)&&(input->rtyp==IDHDL)))
366  {
367  memcpy(output,input,sizeof(*output));
368  memset(input,0,sizeof(*input));
369  return FALSE;
370  }
371  else if (outputType==ANY_TYPE)
372  {
373  output->rtyp=ANY_TYPE;
374  output->data=(char *)(long)input->Typ();
375  /* the name of the object:*/
376  if (input->e==NULL)
377  {
378  if (input->rtyp==IDHDL)
379  /* preserve name: copy it */
380  output->name=omStrDup(IDID((idhdl)(input->data)));
381  else if (input->name!=NULL)
382  {
383  if (input->rtyp==ALIAS_CMD)
384  output->name=omStrDup(input->name);
385  else
386  {
387  output->name=input->name;
388  input->name=NULL;
389  }
390  }
391  else if ((input->rtyp==POLY_CMD) && (input->name==NULL))
392  {
393  if (input->data!=NULL)
394  {
395  int nr=pIsPurePower((poly)input->data);
396  if (nr!=0)
397  {
398  if (pGetExp((poly)input->data,nr)==1)
399  {
400  output->name=omStrDup(currRing->names[nr-1]);
401  }
402  else
403  {
404  char *tmp=(char *)omAlloc(4);
405  sprintf(tmp,"%c%d",*(currRing->names[nr-1]),
406  (int)pGetExp((poly)input->data,nr));
407  output->name=tmp;
408  }
409  }
410  else if(pIsConstant((poly)input->data))
411  {
412  StringSetS("");
413  number n=(pGetCoeff((poly)input->data));
414  n_Write(n, currRing->cf);
415  (pGetCoeff((poly)input->data))=n;
416  output->name=StringEndS();
417  }
418  }
419  }
420  else if ((input->rtyp==NUMBER_CMD) && (input->name==NULL))
421  {
422  StringSetS("");
423  number n=(number)input->data;
424  n_Write(n, currRing->cf);
425  input->data=(void*)n;
426  output->name=StringEndS();
427  }
428  else
429  {
430  /* no need to preserve name: use it */
431  output->name=input->name;
432  memset(input,0,sizeof(*input));
433  }
434  }
435  output->next=input->next;
436  input->next=NULL;
437  return errorreported;
438  }
439  if (index!=0) /* iiTestConvert does not returned 'failure' */
440  {
441  index--;
442 
443  if((dConvertTypes[index].i_typ==inputType)
444  &&(dConvertTypes[index].o_typ==outputType))
445  {
446  if(traceit&TRACE_CONV)
447  {
448  Print("automatic conversion %s -> %s\n",
449  Tok2Cmdname(inputType),Tok2Cmdname(outputType));
450  }
451  if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
452  return TRUE;
453  output->rtyp=outputType;
454  if (dConvertTypes[index].p!=NULL)
455  {
456  output->data=dConvertTypes[index].p(input->CopyD());
457  }
458  else
459  {
460  dConvertTypes[index].pl(output,input);
461  }
462  if ((output->data==NULL)
463  && ((outputType!=INT_CMD)
464  &&(outputType!=POLY_CMD)
465  &&(outputType!=VECTOR_CMD)
466  &&(outputType!=NUMBER_CMD)))
467  {
468  return TRUE;
469  }
470  if (errorreported) return TRUE;
471  output->next=input->next;
472  input->next=NULL;
473  //if (outputType==MATRIX_CMD) Print("convert %d -> matrix\n",inputType);
474  return FALSE;
475  }
476  }
477  return TRUE;
478 }
#define pIsPurePower(p)
Definition: polys.h:231
Class used for (list of) interpreter objects.
Definition: subexpr.h:84
#define ANY_TYPE
Definition: tok.h:30
#define Print
Definition: emacs.cc:83
Definition: tok.h:94
Subexpr e
Definition: subexpr.h:107
#define IDID(a)
Definition: ipid.h:119
#define FALSE
Definition: auxiliary.h:97
return P p
Definition: myNF.cc:203
#define TRACE_CONV
Definition: reporter.h:47
#define TRUE
Definition: auxiliary.h:101
char * StringEndS()
Definition: reporter.cc:151
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
int Typ()
Definition: subexpr.cc:979
#define omAlloc(size)
Definition: omAllocDecl.h:210
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:31
void * data
Definition: subexpr.h:90
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
Definition: tok.h:57
const char * name
Definition: subexpr.h:89
void StringSetS(const char *st)
Definition: reporter.cc:128
static FORCE_INLINE void n_Write(number &n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:595
#define pIsConstant(p)
like above, except that Comp might be != 0
Definition: polys.h:221
short errorreported
Definition: feFopen.cc:23
leftv next
Definition: subexpr.h:88
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
Definition: tok.h:34
#define NULL
Definition: omList.c:10
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:128
int rtyp
Definition: subexpr.h:93
polyrec * poly
Definition: hilb.h:10
void * CopyD(int t)
Definition: subexpr.cc:679
#define omStrDup(s)
Definition: omAllocDecl.h:263

§ iiDummy()

static void* iiDummy ( void *  data)
static

Definition at line 142 of file ipconv.cc.

143 {
144  return data;
145 }

§ iiI2BI()

static void* iiI2BI ( void *  data)
static

Definition at line 172 of file ipconv.cc.

173 {
174  number n=n_Init((int)(long)data, coeffs_BIGINT);
175  return (void *)n;
176 }
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:542
coeffs coeffs_BIGINT
Definition: ipid.cc:54

§ iiI2Id()

static void* iiI2Id ( void *  data)
static

Definition at line 87 of file ipconv.cc.

88 {
89  ideal I=idInit(1,1);
90  I->m[0]=pISet((int)(long)data);
91  return (void *)I;
92 }
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define pISet(i)
Definition: polys.h:295

§ iiI2Iv()

static void* iiI2Iv ( void *  data)
static

Definition at line 159 of file ipconv.cc.

160 {
161  int s=(int)(long)data;
162  intvec *iv=new intvec(s,s);
163  return (void *)iv;
164 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
Definition: intvec.h:14

§ iiI2N()

static void* iiI2N ( void *  data)
static

Definition at line 166 of file ipconv.cc.

167 {
168  number n=nInit((int)(long)data);
169  return (void *)n;
170 }
#define nInit(i)
Definition: numbers.h:24

§ iiI2NN()

static void* iiI2NN ( void *  data)
static

Definition at line 179 of file ipconv.cc.

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 }
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define omAlloc(size)
Definition: omAllocDecl.h:210
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
#define NULL
Definition: omList.c:10
#define nInit(i)
Definition: numbers.h:24

§ iiI2P()

static void* iiI2P ( void *  data)
static

Definition at line 45 of file ipconv.cc.

46 {
47  poly p=pISet((int)(long)data);
48  return (void *)p;
49 }
return P p
Definition: myNF.cc:203
polyrec * poly
Definition: hilb.h:10
#define pISet(i)
Definition: polys.h:295

§ iiI2V()

static void* iiI2V ( void *  data)
static

Definition at line 65 of file ipconv.cc.

66 {
67  poly p=pISet((int)(long)data);
68  if (p!=NULL) pSetComp(p,1);
69  return (void *)p;
70 }
return P p
Definition: myNF.cc:203
#define pSetComp(p, v)
Definition: polys.h:38
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10
#define pISet(i)
Definition: polys.h:295

§ iiIm2Bim()

static void* iiIm2Bim ( void *  data)
static

Definition at line 279 of file ipconv.cc.

280 {
281  intvec *iv=(intvec*)data;
282  void *r=(void *)iv2bim(iv,coeffs_BIGINT);
283  delete iv;
284  return r;
285 }
bigintmat * iv2bim(intvec *b, const coeffs C)
Definition: bigintmat.cc:352
coeffs coeffs_BIGINT
Definition: ipid.cc:54
const ring r
Definition: syzextra.cc:208
Definition: intvec.h:14

§ iiIm2Ma()

static void* iiIm2Ma ( void *  data)
static

Definition at line 262 of file ipconv.cc.

263 {
264  int i, j;
265  intvec *iv = (intvec *)data;
266  matrix m = mpNew(iv->rows(), iv->cols());
267 
268  for (i=iv->rows(); i>0; i--)
269  {
270  for (j=iv->cols(); j>0; j--)
271  {
272  MATELEM(m, i, j) = pISet(IMATELEM(*iv, i, j));
273  }
274  }
275  delete iv;
276  return (void *)m;
277 }
int rows() const
Definition: intvec.h:88
Definition: intvec.h:14
int j
Definition: myNF.cc:70
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:48
int cols() const
Definition: intvec.h:87
#define pISet(i)
Definition: polys.h:295
#define IMATELEM(M, I, J)
Definition: intvec.h:77
#define MATELEM(mat, i, j)
Definition: matpol.h:29

§ iiL2R()

static void iiL2R ( leftv  out,
leftv  in 
)
static

Definition at line 335 of file ipconv.cc.

336 {
337  int add_row_shift = 0;
338  lists l=(lists)in->Data();
339  intvec *ww=NULL;
340  if (l->nr>=0) ww=(intvec *)atGet(&(l->m[0]),"isHomog",INTVEC_CMD);
341  out->data=(void *)syConvList(l);
342  if (ww!=NULL)
343  {
344  intvec *weights=ivCopy(ww);
345  atSet(out,"isHomog",weights,INTVEC_CMD);
346  }
347 }
sleftv * m
Definition: lists.h:45
void atSet(idhdl root, const char *name, void *data, int typ)
Definition: attrib.cc:156
Definition: lists.h:22
intvec * ivCopy(const intvec *o)
Definition: intvec.h:126
syStrategy syConvList(lists li)
Definition: ipshell.cc:3161
void * data
Definition: subexpr.h:90
Definition: intvec.h:14
Definition: tok.h:99
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition: attrib.cc:135
int nr
Definition: lists.h:43
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
void * Data()
Definition: subexpr.cc:1121
int l
Definition: cfEzgcd.cc:94

§ iiMa2Mo()

static void* iiMa2Mo ( void *  data)
static

Definition at line 153 of file ipconv.cc.

154 {
155  void *res=id_Matrix2Module((matrix)data,currRing);
156  return res;
157 }
poly res
Definition: myNF.cc:322
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
ideal id_Matrix2Module(matrix mat, const ring R)

§ iiMo2Ma()

static void* iiMo2Ma ( void *  data)
static

Definition at line 147 of file ipconv.cc.

148 {
149  void *res=id_Module2Matrix((ideal)data,currRing);
150  return res;
151 }
poly res
Definition: myNF.cc:322
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
matrix id_Module2Matrix(ideal mod, const ring R)

§ iiN2Ma()

static void* iiN2Ma ( void *  data)
static

Definition at line 301 of file ipconv.cc.

302 {
303  ideal I=idInit(1,1);
304  if (!nIsZero((number)data))
305  {
306  poly p=pNSet((number)data);
307  I->m[0]=p;
308  }
309  //else
310  //{
311  // nDelete((number *)&data);
312  //}
313  return (void *)I;
314 }
#define pNSet(n)
Definition: polys.h:296
return P p
Definition: myNF.cc:203
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define nIsZero(n)
Definition: numbers.h:19
polyrec * poly
Definition: hilb.h:10

§ iiN2P()

static void * iiN2P ( void *  data)
static

Definition at line 287 of file ipconv.cc.

288 {
289  poly p=NULL;
290  if (!nIsZero((number)data))
291  {
292  p=pNSet((number)data);
293  }
294  //else
295  //{
296  // nDelete((number *)&data);
297  //}
298  return (void *)p;
299 }
#define pNSet(n)
Definition: polys.h:296
return P p
Definition: myNF.cc:203
#define nIsZero(n)
Definition: numbers.h:19
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10

§ iiNN2N()

static void* iiNN2N ( void *  data)
static

Definition at line 231 of file ipconv.cc.

232 {
233  number2 d=(number2)data;
234  if ((currRing==NULL)
235  || (currRing->cf!=d->cf))
236  {
237  WerrorS("cannot convert: incompatible");
238  return NULL;
239  }
240  number n = n_Copy(d->n, d->cf);
241  n2Delete(d);
242  return (void*)n;
243 }
void n2Delete(number2 &d)
Definition: number2.cc:285
void WerrorS(const char *s)
Definition: feFopen.cc:24
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:455

§ iiNN2P()

static void* iiNN2P ( void *  data)
static

Definition at line 247 of file ipconv.cc.

248 {
249  number2 d=(number2)data;
250  if ((currRing==NULL)
251  || (currRing->cf!=d->cf))
252  {
253  WerrorS("cannot convert: incompatible");
254  return NULL;
255  }
256  number n = n_Copy(d->n, d->cf);
257  n2Delete(d);
258  return (void*)p_NSet(n,currRing);
259 }
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1443
void n2Delete(number2 &d)
Definition: number2.cc:285
void WerrorS(const char *s)
Definition: feFopen.cc:24
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:455

§ iiP2Id()

static void* iiP2Id ( void *  data)
static

Definition at line 116 of file ipconv.cc.

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 }
#define pMaxComp(p)
Definition: polys.h:282
return P p
Definition: myNF.cc:203
#define pGetComp(p)
Component.
Definition: polys.h:37
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10

§ iiP2V()

static void* iiP2V ( void *  data)
static

Definition at line 109 of file ipconv.cc.

110 {
111  poly p=(poly)data;
112  if (p!=NULL) pSetCompP(p,1);
113  return (void *)p;
114 }
return P p
Definition: myNF.cc:203
#define pSetCompP(a, i)
Definition: polys.h:286
#define NULL
Definition: omList.c:10
polyrec * poly
Definition: hilb.h:10

§ iiR2L_l()

static void iiR2L_l ( leftv  out,
leftv  in 
)
static

Definition at line 324 of file ipconv.cc.

325 {
326  int add_row_shift = 0;
327  intvec *weights=(intvec*)atGet(in,"isHomog",INTVEC_CMD);
328  if (weights!=NULL) add_row_shift=weights->min_in();
329 
330  syStrategy tmp=(syStrategy)in->CopyD();
331 
332  out->data=(void *)syConvRes(tmp,TRUE,add_row_shift);
333 }
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
Definition: ipshell.cc:3088
#define TRUE
Definition: auxiliary.h:101
int min_in()
Definition: intvec.h:113
void * data
Definition: subexpr.h:90
Definition: intvec.h:14
Definition: tok.h:99
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition: attrib.cc:135
#define NULL
Definition: omList.c:10
void * CopyD(int t)
Definition: subexpr.cc:679
ssyStrategy * syStrategy
Definition: syz.h:35

§ iiS2Link()

static void* iiS2Link ( void *  data)
static

Definition at line 316 of file ipconv.cc.

317 {
319  slInit(l, (char *) data);
320  omFree((ADDRESS)data);
321  return (void *)l;
322 }
void * ADDRESS
Definition: auxiliary.h:118
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
int l
Definition: cfEzgcd.cc:94

§ iiTestConvert()

int iiTestConvert ( int  inputType,
int  outputType,
const struct sConvertTypes dConvertTypes 
)

Definition at line 484 of file ipconv.cc.

485 {
486  if ((inputType==outputType)
487  || (outputType==DEF_CMD)
488  || (outputType==IDHDL)
489  || (outputType==ANY_TYPE))
490  {
491  return -1;
492  }
493  if (inputType==UNKNOWN) return 0;
494 
495  if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
496  return 0;
497  //if ((currRing==NULL) && (outputType==CNUMBER_CMD))
498  // return 0;
499 
500  // search the list
501  int i=0;
502  while (dConvertTypes[i].i_typ!=0)
503  {
504  if((dConvertTypes[i].i_typ==inputType)
505  &&(dConvertTypes[i].o_typ==outputType))
506  {
507  //Print("test convert %d to %d (%s -> %s):%d\n",inputType,outputType,
508  //Tok2Cmdname(inputType), Tok2Cmdname(outputType),i+1);
509  return i+1;
510  }
511  i++;
512  }
513  //Print("test convert %d to %d (%s -> %s):0, tested:%d\n",inputType,outputType,
514  // Tok2Cmdname(inputType), Tok2Cmdname(outputType),i);
515  return 0;
516 }
#define ANY_TYPE
Definition: tok.h:30
#define UNKNOWN
Definition: tok.h:217
#define IDHDL
Definition: tok.h:31
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
Definition: tok.h:57
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10

§ iiV2Ma()

static void* iiV2Ma ( void *  data)
static

Definition at line 129 of file ipconv.cc.

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 }
ip_smatrix * matrix
int m
Definition: cfEzgcd.cc:119
#define MATCOLS(i)
Definition: matpol.h:28
#define pDelete(p_ptr)
Definition: polys.h:169
#define MATROWS(i)
Definition: matpol.h:27
static ideal idVec2Ideal(poly vec)
Definition: ideals.h:156
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
long rank
Definition: matpol.h:20