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 "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	iiBu2P (leftv out, leftv in)
static void *	iiI2V (void *data)
static void *	iiBI2V (void *data)
static void *	iiI2Id (void *data)
static void *	iiBI2Id (void *data)
static void *	iiBu2V (void *data)
static void *	iiP2V (void *data)
static void *	iiBu2Id (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 *	iiBI2N (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 118 of file gentable.cc.

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

Macro Definition Documentation

D

#define D

(

A

)

A

Definition at line 428 of file ipconv.cc.

IPCONV

#define IPCONV

Definition at line 427 of file ipconv.cc.

NULL_VAL

#define NULL_VAL   NULL

Definition at line 429 of file ipconv.cc.

Typedef Documentation

iiConvertProc

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

Definition at line 32 of file ipconv.cc.

iiConvertProcL

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

Definition at line 33 of file ipconv.cc.

Function Documentation

iiBI2Id()

static void * iiBI2Id ( void *  data )

static

Definition at line 101 of file ipconv.cc.

{
  ideal I=idInit(1,1);
  nMapFunc nMap=n_SetMap(coeffs_BIGINT,currRing->cf);
  if (nMap==NULL)
  {
    Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
    return NULL;
  }
  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
  n_Delete((number *)&data,coeffs_BIGINT);
  poly p=pNSet(n);
  I->m[0]=p;
  return (void *)I;
}

iiBI2N()

static void * iiBI2N ( void *  data )

static

Definition at line 241 of file ipconv.cc.

{
  if (currRing==NULL) return NULL;
  nMapFunc nMap=n_SetMap(coeffs_BIGINT,currRing->cf);
  if (nMap==NULL)
  {
    Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
    return NULL;
  }
  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
  n_Delete((number *)&data, coeffs_BIGINT);
  return (void*)n;
}

iiBI2P()

static void * iiBI2P ( void *  data )

static

Definition at line 50 of file ipconv.cc.

{
  nMapFunc nMap=n_SetMap(coeffs_BIGINT,currRing->cf);
  if (nMap==NULL)
  {
    Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
    return NULL;
  }
  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
  n_Delete((number *)&data, coeffs_BIGINT);
  poly p=p_NSet(n, currRing);
  return (void *)p;
}

iiBI2V()

static void * iiBI2V ( void *  data )

static

Definition at line 79 of file ipconv.cc.

{
  nMapFunc nMap=n_SetMap(coeffs_BIGINT,currRing->cf);
  if (nMap==NULL)
  {
    Werror("no conversion from bigint to %s", nCoeffName(currRing->cf));
    return NULL;
  }
  number n=nMap((number)data,coeffs_BIGINT,currRing->cf);
  n_Delete((number *)&data, coeffs_BIGINT);
  poly p=p_NSet(n, currRing);
  if (p!=NULL) pSetComp(p,1);
  return (void *)p;
}

iiBu2Id()

static void * iiBu2Id ( void *  data )

static

Definition at line 136 of file ipconv.cc.

{
  ideal I=idInit(1,1);
 
  if (data!=NULL)
  {
    sBucket_pt b=(sBucket_pt)data;
    poly p; int l;
    sBucketDestroyAdd(b,&p,&l);
    I->m[0]=p;
  }
  return (void *)I;
}

iiBu2P()

static void iiBu2P ( leftv  out, leftv  in  )

static

Definition at line 64 of file ipconv.cc.

{
  sBucket_pt b=(sBucket_pt)in->CopyD();
  poly p; int l;
  sBucketDestroyAdd(b,&p,&l);
  out->data=(void*)p;
}

iiBu2V()

static void * iiBu2V ( void *  data )

static

Definition at line 116 of file ipconv.cc.

{
  poly p=NULL;
  if (data!=NULL)
  {
    sBucket_pt b=(sBucket_pt)data;
    int l;
    sBucketDestroyAdd(b,&p,&l);
    if (p!=NULL) pSetCompP(p,1);
  }
  return (void *)p;
}

iiConvert()

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

Definition at line 435 of file ipconv.cc.

{
  output->Init();
  if ((inputType==outputType)
  || (outputType==DEF_CMD)
  || ((outputType==IDHDL)&&(input->rtyp==IDHDL)))
  {
    memcpy(output,input,sizeof(*output));
    input->Init();
    return FALSE;
  }
  else if (outputType==ANY_TYPE)
  {
    output->rtyp=ANY_TYPE;
    output->data=(char *)(long)input->Typ();
    /* the name of the object:*/
    if (input->e==NULL)
    {
      if (input->rtyp==IDHDL)
      /* preserve name: copy it */
        output->name=omStrDup(IDID((idhdl)(input->data)));
      else if (input->name!=NULL)
      {
        if (input->rtyp==ALIAS_CMD)
        output->name=omStrDup(input->name);
        else
        {
          output->name=input->name;
          input->name=NULL;
        }
      }
      else if ((input->rtyp==POLY_CMD) && (input->name==NULL))
      {
        if (input->data!=NULL)
        {
          int nr=pIsPurePower((poly)input->data);
          if (nr!=0)
          {
            if (pGetExp((poly)input->data,nr)==1)
            {
              output->name=omStrDup(currRing->names[nr-1]);
            }
            else
            {
              char *tmp=(char *)omAlloc(4);
              sprintf(tmp,"%c%d",*(currRing->names[nr-1]),
                (int)pGetExp((poly)input->data,nr));
              output->name=tmp;
            }
          }
          else if(pIsConstant((poly)input->data))
          {
            StringSetS("");
            number n=(pGetCoeff((poly)input->data));
            n_Write(n, currRing->cf);
            (pGetCoeff((poly)input->data))=n; // n_Write may have changed n
            output->name=StringEndS();
          }
        }
      }
      else if ((input->rtyp==NUMBER_CMD) && (input->name==NULL))
      {
        StringSetS("");
        number n=(number)input->data;
        n_Write(n, currRing->cf);
        input->data=(void*)n; // n_Write may have changed n
        output->name=StringEndS();
      }
      else
      {
        /* no need to preserve name: use it */
        output->name=input->name;
        input->name=NULL;
      }
    }
    output->next=input->next;
    input->next=NULL;
    if (!errorreported) input->CleanUp();
    return errorreported;
  }
  if (index!=0) /* iiTestConvert does not returned 'failure' */
  {
    index--;
 
    if((dConvertTypes[index].i_typ==inputType)
    &&(dConvertTypes[index].o_typ==outputType))
    {
      if(traceit&TRACE_CONV)
      {
        Print("automatic  conversion %s -> %s\n",
        Tok2Cmdname(inputType),Tok2Cmdname(outputType));
      }
      if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
        return TRUE;
      output->rtyp=outputType;
      if (dConvertTypes[index].p!=NULL)
      {
        output->data=dConvertTypes[index].p(input->CopyD());
      }
      else
      {
        dConvertTypes[index].pl(output,input);
      }
      if ((output->data==NULL)
      && ((outputType!=INT_CMD)
        &&(outputType!=POLY_CMD)
        &&(outputType!=VECTOR_CMD)
        &&(outputType!=NUMBER_CMD)))
      {
        return TRUE;
      }
      if (errorreported) return TRUE;
      output->next=input->next;
      input->next=NULL;
      if ((input->rtyp!=IDHDL) && (input->attribute!=NULL))
      {
        input->attribute->killAll(currRing);
        input->attribute=NULL;
      }
      if (input->e!=NULL)
      {
        Subexpr h;
        while (input->e!=NULL)
        {
          h=input->e->next;
          omFreeBin((ADDRESS)input->e, sSubexpr_bin);
          input->e=h;
        }
      }
      //input->Init(); // seems that input (rtyp?) is still needed
      return FALSE;
    }
  }
  return TRUE;
}

iiDummy()

static void * iiDummy ( void *  data )

static

Definition at line 176 of file ipconv.cc.

{
  return data;
}

iiI2BI()

static void * iiI2BI ( void *  data )

static

Definition at line 206 of file ipconv.cc.

{
  number n=n_Init((int)(long)data, coeffs_BIGINT);
  return (void *)n;
}

iiI2Id()

static void * iiI2Id ( void *  data )

static

Definition at line 94 of file ipconv.cc.

{
  ideal I=idInit(1,1);
  I->m[0]=pISet((int)(long)data);
  return (void *)I;
}

iiI2Iv()

static void * iiI2Iv ( void *  data )

static

Definition at line 193 of file ipconv.cc.

{
  int s=(int)(long)data;
  intvec *iv=new intvec(s,s);
  return (void *)iv;
}

iiI2N()

static void * iiI2N ( void *  data )

static

Definition at line 200 of file ipconv.cc.

{
  number n=nInit((int)(long)data);
  return (void *)n;
}

iiI2P()

static void * iiI2P ( void *  data )

static

Definition at line 44 of file ipconv.cc.

{
  poly p=pISet((int)(long)data);
  return (void *)p;
}

iiI2V()

static void * iiI2V ( void *  data )

static

Definition at line 72 of file ipconv.cc.

{
  poly p=pISet((int)(long)data);
  if (p!=NULL) pSetComp(p,1);
  return (void *)p;
}

iiIm2Bim()

static void * iiIm2Bim ( void *  data )

static

Definition at line 354 of file ipconv.cc.

{
  intvec *iv=(intvec*)data;
  void *r=(void *)iv2bim(iv,coeffs_BIGINT);
  delete iv;
  return r;
}

iiIm2Ma()

static void * iiIm2Ma ( void *  data )

static

Definition at line 337 of file ipconv.cc.

{
  int i, j;
  intvec *iv = (intvec *)data;
  matrix m = mpNew(iv->rows(), iv->cols());
 
  for (i=iv->rows(); i>0; i--)
  {
    for (j=iv->cols(); j>0; j--)
    {
      MATELEM(m, i, j) = pISet(IMATELEM(*iv, i, j));
    }
  }
  delete iv;
  return (void *)m;
}

iiL2R()

static void iiL2R ( leftv  out, leftv  in  )

static

Definition at line 410 of file ipconv.cc.

{
  //int add_row_shift = 0;
  lists l=(lists)in->Data();
  intvec *ww=NULL;
  if (l->nr>=0) ww=(intvec *)atGet(&(l->m[0]),"isHomog",INTVEC_CMD);
  out->data=(void *)syConvList(l);
  if (ww!=NULL)
  {
    intvec *weights=ivCopy(ww);
    atSet(out,omStrDup("isHomog"),weights,INTVEC_CMD);
  }
}

iiMa2Mo()

static void * iiMa2Mo ( void *  data )

static

Definition at line 187 of file ipconv.cc.

{
  void *res=id_Matrix2Module((matrix)data,currRing);
  return res;
}

iiMo2Ma()

static void * iiMo2Ma ( void *  data )

static

Definition at line 181 of file ipconv.cc.

{
  void *res=id_Module2Matrix((ideal)data,currRing);
  return res;
}

iiN2Ma()

static void * iiN2Ma ( void *  data )

static

Definition at line 376 of file ipconv.cc.

{
  ideal I=idInit(1,1);
  if (!nIsZero((number)data))
  {
    poly p=pNSet((number)data);
    I->m[0]=p;
  }
  //else
  //{
  //  nDelete((number *)&data);
  //}
  return (void *)I;
}

iiN2P()

static void * iiN2P ( void *  data )

static

Definition at line 362 of file ipconv.cc.

{
  poly p=NULL;
  if (!nIsZero((number)data))
  {
    p=pNSet((number)data);
  }
  //else
  //{
  //  nDelete((number *)&data);
  //}
  return (void *)p;
}

iiP2Id()

static void * iiP2Id ( void *  data )

static

Definition at line 150 of file ipconv.cc.

{
  ideal I=idInit(1,1);
 
  if (data!=NULL)
  {
    poly p=(poly)data;
    I->m[0]=p;
    if (pGetComp(p)!=0) I->rank=pMaxComp(p);
  }
  return (void *)I;
}

iiP2V()

static void * iiP2V ( void *  data )

static

Definition at line 129 of file ipconv.cc.

{
  poly p=(poly)data;
  if (p!=NULL) pSetCompP(p,1);
  return (void *)p;
}

iiR2L_l()

static void iiR2L_l ( leftv  out, leftv  in  )

static

Definition at line 399 of file ipconv.cc.

{
  int add_row_shift = 0;
  intvec *weights=(intvec*)atGet(in,"isHomog",INTVEC_CMD);
  if (weights!=NULL)  add_row_shift=weights->min_in();
 
  syStrategy tmp=(syStrategy)in->CopyD();
 
  out->data=(void *)syConvRes(tmp,TRUE,add_row_shift);
}

iiS2Link()

static void * iiS2Link ( void *  data )

static

Definition at line 391 of file ipconv.cc.

{
  si_link l=(si_link)omAlloc0Bin(ip_link_bin);
  slInit(l, (char *) data);
  omFree((ADDRESS)data);
  return (void *)l;
}

iiTestConvert()

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

Definition at line 575 of file ipconv.cc.

{
  if ((inputType==outputType)
  || (outputType==DEF_CMD)
  || (outputType==IDHDL)
  || (outputType==ANY_TYPE))
  {
    return -1;
  }
  if (inputType==UNKNOWN) return 0;
 
  if ((currRing==NULL) && (outputType>BEGIN_RING) && (outputType<END_RING))
    return 0;
  //if ((currRing==NULL) && (outputType==CNUMBER_CMD))
  //  return 0;
 
  // search the list
  int i=0;
  while (dConvertTypes[i].i_typ!=0)
  {
    if((dConvertTypes[i].i_typ==inputType)
    &&(dConvertTypes[i].o_typ==outputType))
    {
      //Print("test convert %d to %d (%s -> %s):%d\n",inputType,outputType,
      //Tok2Cmdname(inputType), Tok2Cmdname(outputType),i+1);
      return i+1;
    }
    i++;
  }
  //Print("test convert %d to %d (%s -> %s):0, tested:%d\n",inputType,outputType,
  // Tok2Cmdname(inputType), Tok2Cmdname(outputType),i);
  return 0;
}

iiV2Ma()

static void * iiV2Ma ( void *  data )

static

Definition at line 163 of file ipconv.cc.

{
  matrix m=(matrix)idVec2Ideal((poly)data);
  int h=MATCOLS(m);
  MATCOLS(m)=MATROWS(m);
  MATROWS(m)=h;
  m->rank=h;
  pDelete((poly *)&data);
  return (void *)m;
}