ipconv.h File Reference

#include "kernel/structs.h"

Go to the source code of this file.

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

Variables
const struct sConvertTypes	dConvertTypes []

Function Documentation

iiConvert()

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

Definition at line 450 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(8);
              snprintf(tmp,8,"%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;
}

iiTestConvert()

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

Definition at line 590 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;
}

Variable Documentation

dConvertTypes

const struct sConvertTypes dConvertTypes[]

extern

Definition at line 1321 of file table.h.

                                           {
//   input type       output type     convert procedure(destr.)/(non-destr.)
//  int -> bigint
   { INT_CMD,         BIGINT_CMD,     D(iiI2BI) , NULL_VAL },
   { INT_CMD,         BIGINTVEC_CMD,  D(iiI2BIV) , NULL_VAL },
//  int -> number
   { INT_CMD,         NUMBER_CMD,     D(iiI2N) , NULL_VAL },
   { BIGINT_CMD,      NUMBER_CMD,     D(iiBI2N) , NULL_VAL },
//  int -> poly
   { INT_CMD,         POLY_CMD,       D(iiI2P) , NULL_VAL },
   { BIGINT_CMD,      POLY_CMD,       D(iiBI2P) , NULL_VAL },
   { BUCKET_CMD,      POLY_CMD,       NULL_VAL,   D(iiBu2P) },
//  int -> vector
   { INT_CMD,         VECTOR_CMD,     D(iiI2V) , NULL_VAL },
   { BIGINT_CMD,      VECTOR_CMD,     D(iiBI2V) , NULL_VAL },
//  int -> ideal
   { INT_CMD,         IDEAL_CMD,      D(iiI2Id) , NULL_VAL },
   { BIGINT_CMD,      IDEAL_CMD,      D(iiBI2Id) , NULL_VAL },
//  int -> matrix
   { INT_CMD,         MATRIX_CMD,     D(iiI2Id) , NULL_VAL },
   { BIGINT_CMD,      MATRIX_CMD,     D(iiBI2Id) , NULL_VAL },
//  int -> intvec
   { INT_CMD,         INTVEC_CMD,     D(iiI2Iv) , NULL_VAL },
//  intvec -> intmat
   { INTVEC_CMD,      INTMAT_CMD,     D(iiDummy), NULL_VAL },
   { INTVEC_CMD,      BIGINTVEC_CMD,  D(iiIV2BIV), NULL_VAL },
//  intvec -> matrix
   { INTVEC_CMD,      MATRIX_CMD,     D(iiIm2Ma) , NULL_VAL },
//  intmat -> bigintmat
   { INTMAT_CMD,      BIGINTMAT_CMD,  D(iiIm2Bim) , NULL_VAL },
//  intmat -> matrix
   { INTMAT_CMD,      MATRIX_CMD,     D(iiIm2Ma) , NULL_VAL },
//  bigintvec -> bigintmat
   { BIGINTVEC_CMD,   BIGINTMAT_CMD,  D(iiDummy) , NULL_VAL },
//  number -> poly
   { NUMBER_CMD,      POLY_CMD,       D(iiN2P)  , NULL_VAL },
//  number -> matrix
   { NUMBER_CMD,      MATRIX_CMD,     D(iiN2Ma)  , NULL_VAL },
//  number -> ideal
//  number -> vector
//  number -> module
//  poly -> number
//  poly -> ideal
   { POLY_CMD,        IDEAL_CMD,      D(iiP2Id) , NULL_VAL },
//  poly -> vector
   { POLY_CMD,        VECTOR_CMD,     D(iiP2V) , NULL_VAL },
//  poly -> matrix
   { POLY_CMD,        MATRIX_CMD,     D(iiP2Id) , NULL_VAL },
// the same for polyBucket:
   { BUCKET_CMD,      IDEAL_CMD,      D(iiBu2Id) , NULL_VAL },
   { BUCKET_CMD,      VECTOR_CMD,     D(iiBu2V) , NULL_VAL },
   { BUCKET_CMD,      MATRIX_CMD,     D(iiBu2Id) , NULL_VAL },
//  vector -> module
   { VECTOR_CMD,      MODUL_CMD,      D(iiP2Id) , NULL_VAL },
//  vector -> matrix
   { VECTOR_CMD,      MATRIX_CMD,     D(iiV2Ma) , NULL_VAL },
//  ideal -> module
   { IDEAL_CMD,       MODUL_CMD,      D(iiMa2Mo) , NULL_VAL },
//  ideal -> matrix
   { IDEAL_CMD,       MATRIX_CMD,     D(iiDummy) , NULL_VAL },
//  module -> matrix
   { MODUL_CMD,       MATRIX_CMD,     D(iiMo2Ma) , NULL_VAL },
//  matrix -> ideal
//  matrix -> module
   { MATRIX_CMD,      MODUL_CMD,      D(iiMa2Mo) , NULL_VAL },
//  intvec
//  string -> link
   { STRING_CMD,      LINK_CMD,       D(iiS2Link) , NULL_VAL },
// resolution -> list
   { RESOLUTION_CMD,  LIST_CMD,       NULL_VAL , D(iiR2L_l) },
// list -> resolution
   { LIST_CMD,        RESOLUTION_CMD, NULL_VAL ,  D(iiL2R) },
// matrix -> smatrix
   { MATRIX_CMD,      SMATRIX_CMD,    D(iiMa2Mo), NULL_VAL },
// module -> smatrix
   { MODUL_CMD,       SMATRIX_CMD,    D(iiDummy), NULL_VAL },
// smatrix -> matrix
   { SMATRIX_CMD,     MATRIX_CMD,     D(iiMo2Ma) , NULL_VAL },
// smatrix -> module
   { SMATRIX_CMD,     MODUL_CMD,      D(iiDummy) , NULL_VAL },
#ifdef SINGULAR_4_2
   { INT_CMD,         CNUMBER_CMD,    D(iiI2NN) , NULL_VAL },
   { BIGINT_CMD,      CNUMBER_CMD,    D(iiBI2NN) , NULL_VAL },
   { CNUMBER_CMD,     NUMBER_CMD,     D(iiNN2N) , NULL_VAL },
   { CNUMBER_CMD,     POLY_CMD,       D(iiNN2P) , NULL_VAL },
   { INT_CMD,         CPOLY_CMD,      D(iiI2CP), NULL_VAL },
   { BIGINT_CMD,      CPOLY_CMD,      D(iiBI2CP), NULL_VAL },
//   { NUMBER_CMD,      CPOLY_CMD,      D(iiN2CP), NULL_VAL },
   { POLY_CMD,        CPOLY_CMD,      D(iiP2CP), NULL_VAL },
#endif
//  end of list
   { 0,               0,              NULL_VAL , NULL_VAL }
};