Changeset 82dbf50 in git


Ignore:
Timestamp:
Nov 13, 1998, 1:23:30 PM (26 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'c7af8613769b29c741d6c338945669719f1fc4f8')
Children:
ce231a8f0acfcf9ed523fee24f2e3e3e5f4546fc
Parents:
77cd73322377d191a66a922a4de320404c6c9304
Message:
* minor changes


git-svn-id: file:///usr/local/Singular/svn/trunk@2675 2c84dea3-7e68-4137-9b89-c4e89433aadc
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • MP/MP/MP.h

    r77cd73 r82dbf50  
    21732173#define MP_CopPolyFacStd                43
    21742174#define MP_CopPolyResultant             44
     2175#define MP_CopPolyFreeModule            45
    21752176
    21762177/***************************************************************************
  • MP/MP/h/MP_PolyDict.h

    r77cd73 r82dbf50  
    120120#define MP_CopPolyFacStd                43
    121121#define MP_CopPolyResultant             44
     122#define MP_CopPolyFreeModule            45
    122123
    123124/***************************************************************************
  • MP/MPT/GP.h

    r77cd73 r82dbf50  
    6161public:
    6262  // has to say what kind of specification it is
    63   virtual GP_Type_t     Type()      {return GP_UnknownType;}
    64   virtual GP_Atom_pt    Atom()      {return NULL;}
    65   virtual GP_Comp_pt    Comp()      {return NULL;}
    66   virtual GP_Poly_pt    Poly()      {return NULL;}
     63  virtual GP_Type_t     Type()      = 0;
     64  virtual GP_Atom_pt    Atom()      = 0;
     65  virtual GP_Comp_pt    Comp()      = 0;
     66  virtual GP_Poly_pt    Poly()      = 0;
    6767 
    6868  // traverses through the spec tree and checks everything for
     
    8383{
    8484public:
    85   virtual int   N()                     = 0;
     85  virtual long   N()                    = 0;
    8686  virtual void* Next()                  = 0;
    8787  virtual void  Reset(const void* data) = 0;
     
    113113  GP_UnknownAtomEncoding,
    114114  GP_DynamicAtomEncoding,
    115   GP_UintAtomEncoding,
    116   GP_SintAtomEncoding,
    117115  GP_UlongAtomEncoding,
    118116  GP_SlongAtomEncoding,
     
    134132
    135133  // the following need to be implemented by a child of GP_Atom_t
    136   virtual GP_AtomType_t AtomType()  = 0;
     134  virtual GP_AtomType_t AtomType()                  = 0;
    137135  // GP_UnknownAtomEncoding: means can only be determined from the atom itself
    138   virtual GP_AtomEncoding_t AtomEncoding()        = 0;
     136  virtual GP_AtomEncoding_t AtomEncoding()          = 0;
    139137  // for GP_CharPAtomType and GP_ModuloAtomType
    140138  // this returns the modulus, otherwise, this returns 0
     
    148146 
    149147  // getting the value of Atoms
    150   virtual unsigned int  AtomUint(const void* data)  {return 0;}
    151   virtual signed int    AtomSint(const void* data)  {return 0;}
    152148  virtual unsigned long AtomUlong(const void* data) {return 0;}
    153149  virtual signed long   AtomSlong(const void* data) {return 0;}
     
    155151  virtual double        AtomDouble(const void* data){return 0.0;}
    156152
    157   virtual   unsigned int   AtomApIntLength(const void* data)   {return 0;}
    158   virtual   signed int     AtomApIntSign(const void* data)     {return 0;}
     153  virtual   unsigned long   AtomApIntLength(const void* data)   {return 0;}
     154  virtual   signed long     AtomApIntSign(const void* data)     {return 0;}
    159155  virtual   void           AtomApInt(const void* data, unsigned long* apint) {}
    160156  virtual   const unsigned long*  AtomApInt(const void* data) {return NULL;}
     
    195191
    196192  // only relevant for matricies
    197   virtual void MatrixDimension(int &dx, int &dy)
     193  virtual void MatrixDimension(long &dx, long &dy)
    198194    {dx = -1; dy = -1;}
    199195
    200196  // only relevant fro Free modules
    201   virtual int   FreeModuleComponent(void* data);
    202   virtual void* FreeModuleElement(void* data);
     197  virtual long   FreeModuleComponent(void* data)    {return -1;}
     198  virtual void*  FreeModuleElement(void* data)      {return NULL;}
    203199};
    204200
     
    222218  bool  IsPolyDataOk(const void* data);
    223219
    224   virtual GP_PolyType_t PolyType()      {return GP_UnknownPolyType;}
    225   virtual GP_UvPoly_pt  UvPoly()        {return NULL;}
    226   virtual GP_MvPoly_pt  MvPoly()        {return NULL;}
     220  virtual GP_PolyType_t PolyType()      = 0;
     221  virtual GP_UvPoly_pt  UvPoly()        = 0;
     222  virtual GP_MvPoly_pt  MvPoly()        = 0;
    227223 
    228224  virtual GP_pt   Coeffs()              = 0;
     
    233229  // interpreted as index of a free vector generator -- i.e. whether
    234230  // poly is actually a vector over a free module
    235   virtual bool      IsFreeModuleVector()        {return false;}
     231  virtual bool      IsFreeModuleVector()    {return false;}
    236232};
    237233
     
    265261  // The next two functions are only relevant for Sparse Univariate polys
    266262  virtual void* ExpCoeff(const void* term)     {return NULL;}
    267   virtual int   ExpValue(const void* term)     {return -1;}
    268 };
    269 
     263  virtual long  ExpValue(const void* term)     {return -1;}
     264};
    270265
    271266
     
    287282  bool  IsMvPolyDataOk(const void* data);
    288283
    289   virtual GP_MvPolyType_t   MvPolyType()    {return GP_UnknownMvPolyType;}
    290   virtual GP_DistMvPoly_pt  DistMvPoly()    {return NULL;}
    291   virtual GP_RecMvPoly_pt   RecMvPoly()     {return NULL;}
     284  virtual GP_MvPolyType_t   MvPolyType()    = 0;
     285  virtual GP_DistMvPoly_pt  DistMvPoly()    = 0;
     286  virtual GP_RecMvPoly_pt   RecMvPoly()     = 0;
    292287 
    293288  // the number of variables of the poly
    294   virtual int   NumberOfVars()              = 0;
     289  virtual long   NumberOfVars()             = 0;
    295290  // iterator for variable names
    296291  virtual GP_Iterator_pt    VarNamesIterator() {return NULL;}
     
    331326  virtual GP_Iterator_pt ExpVectorIterator(const void* monom) {return NULL;}
    332327  // from which we can extract the (number, value) tuple
    333   virtual int ExpValue(void* exp)  {return -1;}
    334   virtual int ExpNumber(void* exp) {return -1;}
     328  virtual long ExpValue(void* exp)  {return -1;}
     329  virtual long ExpNumber(void* exp) {return -1;}
    335330};
    336331
     
    351346  // or a term of the form v^e*MutlSubPoly() + AddSubPoly()
    352347  // index of variable v ( in range 0 to VarNumber()-1)
    353    virtual   int Variable(const void* data)       = 0;   
     348   virtual   long Variable(const void* data)       = 0;   
    354349  // exponent e of v
    355    virtual   int Exponent(const void* data)       = 0;
     350   virtual   long Exponent(const void* data)       = 0;
    356351  // multiplicative subpoly of v
    357352   virtual   void*    MultSubPoly(const void* data)   = 0;
     
    374369  GP_LexOrdering,
    375370  GP_RevLexOrdering,
    376   GP_DegLexOrdering,       // can have pos. integers as weights
    377   GP_DegRevLexOrdering,    // can have pos. integers as weights
     371  GP_DegLexOrdering,       
     372  GP_DegRevLexOrdering,   
    378373
    379374  // local orderings (are complete)
    380375  GP_NegLexOrdering,
    381376  GP_NegRevLexOrdering,
    382   GP_NegDegLexOrdering,    // can have pos. integers as weights
    383   GP_NegDegRevLexOrdering, // can have pos. integers as weights
     377  GP_NegDegLexOrdering,   
     378  GP_NegDegRevLexOrdering,
    384379
    385380  // matrix ordering (is complete)
    386381  GP_MatrixOrdering,     
    387   // extra weight vector ordering (is incomplete)
    388   GP_VectorOrdering,
    389382
    390383  // module orderings (are incomplete)
     
    400393{
    401394public:
    402   bool IsOk(const int nvars);
     395  bool IsOk(const long nvars);
    403396 
    404397  // type
    405   virtual GP_OrderingType_t OrderingType() = 0;
     398  virtual GP_OrderingType_t OrderingType()          = 0;
    406399  GP_OrderingType_t OrderingType(const void* block)
    407400    {return GP_UnknownOrdering;}
     
    414407  virtual GP_Iterator_pt BlockOrderingIterator() {return NULL;}
    415408
    416   virtual void BlockLength(const void* block, int &length)
    417     {length = -1;}
     409  virtual long BlockLength(const void* block)
     410    {return -1;}
    418411
    419412private:
  • MP/MPT/GP_IsOk.cc

    r77cd73 r82dbf50  
    7676 
    7777  if (AtomEncoding() == GP_DynamicAtomEncoding &&
    78       AtomEncoding(data) == GP_UnknownAtomEncoding)
     78      (AtomEncoding(data) == GP_UnknownAtomEncoding ||
     79       AtomEncoding(data) == GP_UnknownAtomEncoding))
    7980    return false;
    8081 
    8182  return true;
    8283}
    83 
    84 
    8584
    8685/////////////////////////////////////////////////////////////////////
     
    9493  GP_pt elements = Elements();
    9594 
    96   if (ctype == GP_UnknownCompType)
     95  if (ctype == GP_UnknownCompType || elements == NULL)
    9796    return false;
    9897 
     
    125124        return true;
    126125
     126      case GP_MatrixCompType:
     127      {
     128        long dx = -1, dy = -1;
     129        MatrixDimension(dx, dy);
     130        if (dx <= 0 || dy <= 0) return false;
     131        return true;
     132      }
     133
    127134      default:
    128135        return true;
     
    134141  GP_pt elements = Elements();
    135142  GP_CompType_t ctype = CompType();
    136   int i, n;
    137  
    138  
    139   if (it == NULL) return false;
     143  long i, n;
     144 
     145 
     146  if (it == NULL || elements == NULL) return false;
    140147  n = it->N();
    141148  if (n < 0) return false;
     
    145152      case GP_MatrixCompType:
    146153      {
    147         int dx, dy;
     154        long dx = -1, dy = -1;
    148155        MatrixDimension(dx, dy);
    149156        if (dx < 0 || dy < 0) return false;
     
    157164        if (n == 0 || n > 2) return false;
    158165        break;
    159        
     166
     167      case GP_FreeModuleCompType:
     168      {
     169        for (i=0; i<n; i++)
     170        {
     171          void* fmel = it->Next();
     172          long comp = FreeModuleComponent(fmel);
     173          if (comp < 0) return false;
     174          if (elements->IsDataOk(FreeModuleElement(fmel)) == false)
     175            return false;
     176        }
     177        return true;
     178      }
     179     
    160180      case GP_UnknownCompType:
    161181        return false;
     
    193213        return false;
    194214  }
    195   if (Coeffs()->IsSpecOk() == false) return false;
     215  if (Coeffs() == NULL || Coeffs()->IsSpecOk() == false) return false;
    196216 
    197217  mpoly = MinPoly();
     
    233253  GP_pt coeff = Coeffs();
    234254
    235   int i, n;
     255  long i, n;
    236256  void* term;
    237257 
     
    320340  GP_pt             coeffs = Coeffs();
    321341  void*             monom;
    322   int i, n,j,       nvars  = NumberOfVars();
     342  long i, n,j,       nvars  = NumberOfVars();
    323343  GP_Iterator_pt    expvector = NULL;
    324344
    325   if (type ==  GP_UnknownDistMvPolyType) return false;
    326   if (monoms == NULL) return false;
    327   if (nvars <= 0) return false;
    328  
    329   n = monoms->N();
    330  
    331   if (n < 0) return false;
     345  if (type ==  GP_UnknownDistMvPolyType ||
     346      monoms == NULL ||
     347      coeffs == NULL ||
     348      nvars <= 0 ||
     349      (n = monoms->N()) < 0)
     350    return false;
    332351 
    333352  for (i=0; i<n; i++)
     
    338357    if (type == GP_SparseDistMvPolyType)
    339358    {
    340       int m;
     359      long m;
    341360      void* exp;
    342361
     
    360379    else
    361380    {
    362       long int* evector = NULL;
     381      long* evector = NULL;
    363382      ExpVector(monom, evector);
    364383     
     
    404423bool GP_Ordering_t::IsBlockOrderingOk(const void* block_ordering)
    405424{
    406   int length;
    407  
    408   BlockLimits(block_ordering, length);
    409  
    410   if (length <= NULL) return false;
     425  long length = BlockLength(block_ordering);
     426 
     427  if (length <= 0) return false;
    411428 
    412429  switch (OrderingType(block_ordering))
     
    416433        return false;
    417434
     435      case GP_IncrCompOrdering:
     436      case GP_DecrCompOrdering:
     437        if (length != 1) return false;
     438        return true;
     439       
    418440      case GP_MatrixOrdering:
    419441      {
    420         GP_Iterator_pt iter = WeightsIterator();
     442        GP_Iterator_pt iter = WeightsIterator(block_ordering);
    421443        if (iter == NULL) return false;
    422444        if (iter->N() != length*length) return false;
     
    425447       
    426448      default:
    427         return true;
     449      {
     450        GP_Iterator_pt iter = WeightsIterator(block_ordering);
     451        if (iter == NULL || iter->N() > 0 && iter->N() <= length)
     452          return true;
     453        return false;
     454      }
    428455  }
    429456}
    430457   
    431 bool GP_Ordering_t::IsOk(const int nvars)
     458bool GP_Ordering_t::IsOk(const long nvars)
    432459{
    433460  if (nvars <= 0) return false;
     
    438465        return false;
    439466       
    440       case GP_VectorOrdering:
    441467      case GP_IncrCompOrdering:
    442468      case GP_DecrCompOrdering:
     
    455481      {
    456482        GP_Iterator_pt iter = BlockOrderingIterator();
    457         int i, n = 0, low, high;
    458         bool found_zero=false, found_nvars=false;
     483        long i, n = 0, length = 0;
    459484        void* block_ordering;
    460485       
     
    465490            block_ordering = iter->Next();
    466491            if (! IsBlockOrderingOk(block_ordering)) return false;
    467             BlockLimits(block_ordering, low, high);
    468          
    469             if (low < 0 || high >= nvars) return false;
    470 
    471             // Hmm.. we should check fo complete coverage of all
    472             // variables However, we would need to allocate memory to do
    473             // so, and I'd like to avoid this here
    474             if (low == 0) found_zero = true;
    475             if (high == nvars -1) found_nvars = true;
     492            length += BlockLength(block_ordering);
    476493          }
    477494        }
    478         return (found_zero && found_nvars);
    479       }
    480      
    481       default:
    482         return true;
    483   }
    484 }
     495        return (length == nvars);
     496      }
     497     
     498      default:
     499      {
     500        GP_Iterator_pt it = WeightsIterator();
     501        if (it == NULL || (it->N() > 0 && it->N() <= nvars)) return true;
     502        return false;
     503      }
     504  }
     505}
     506
    485507
    486508#if 0
  • MP/MPT/MPT_GP.cc

    r77cd73 r82dbf50  
    6767}
    6868
    69 bool MPT_GP_IsValueIterator(MPT_Tree_pt tree, int vtype)
     69bool MPT_GP_IsValueIterator(MPT_Tree_pt tree, long vtype)
    7070{
    7171  if (tree == NULL || tree->node->type != MP_CommonOperatorType)
     
    8585  if (vtype >= 0)
    8686  {
    87     int nc = tree->node->numchild, i;
     87    long nc = tree->node->numchild, i;
    8888    MPT_Arg_pt args;
    8989 
     
    9797}
    9898
    99 MPT_GP_ValueIterator_t::MPT_GP_ValueIterator_t(MPT_Tree_pt tree, int vtype)
     99MPT_GP_ValueIterator_t::MPT_GP_ValueIterator_t(MPT_Tree_pt tree, long vtype)
    100100    : MPT_GP_Iterator_t(tree->node)
    101101{
     
    159159        return GP_UlongAtomEncoding;
    160160      if (mptype == MP_Sint8Type)
    161         return GP_SintAtomEncoding;
     161        return GP_SlongAtomEncoding;
    162162      MPT_Assume(mptype == MP_Uint8Type);
    163       return GP_UintAtomEncoding;
     163      return GP_UlongAtomEncoding;
    164164    }
    165165    else
    166166    {
    167       int format = MPT_GetApIntFormat();
     167      long format = MPT_GetApIntFormat();
    168168      if (format == MP_GMP) return GP_GmpApIntAtomEncoding;
    169169      if (format == MP_PARI) return GP_PariApIntAtomEncoding;
     
    225225}
    226226
    227 unsigned int MPT_GP_Atom_t::AtomUint(const void* data)
    228 {
    229   MPT_Assume(AtomEncoding() == GP_UintAtomEncoding);
    230 
    231   return (unsigned int)
    232     MP_UINT8_T(_tnode != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
    233 }
    234 signed int MPT_GP_Atom_t::AtomSint(const void* data)
    235 {
    236   MPT_Assume(AtomEncoding(data) == GP_SintAtomEncoding);
    237 
    238   return (int)
    239     MP_SINT8_T((_tnode!=NULL ? data : ((MPT_Tree_pt) data)->node->nvalue));
    240 }
    241227unsigned long MPT_GP_Atom_t::AtomUlong(const void* data)
    242228{
     
    287273/////////////////////////////////////////////////////////////////////
    288274static GP_CompType_t
    289 MP_TypeDictOp_2_GP_CompType(int type,
     275MP_TypeDictOp_2_GP_CompType(long type,
    290276                            MP_DictTag_t dict, MP_Common_t cvalue)
    291277{
     
    375361                                      MP_AnnotMatrixDimension);
    376362    MPT_Tree_pt ctree;
    377     int dx, dy;
     363    long dx, dy;
    378364   
    379365    if (tree == NULL || tree->node->type != MP_CommonOperatorType ||
     
    429415MPT_GP_MvPoly_t::MPT_GP_MvPoly_t(MPT_Node_pt tnode,
    430416                                 MPT_GP_pt coeffs,
    431                                  int nvars)
     417                                 long nvars)
    432418    : MPT_GP_Poly_t(tnode, coeffs)
    433419{
     
    449435MPT_GetGP_DistMvPolyType(MPT_Node_pt tnode,
    450436                         MPT_GP_pt &coeffs,
    451                          int &nvars)
     437                         long &nvars)
    452438{
    453439  MPT_Assume(tnode != NULL);
     
    495481
    496482  MPT_GP_pt coeffs;
    497   int nvars;
     483  long nvars;
    498484 
    499485  if (MPT_GetGP_DistMvPolyType(tnode, coeffs, nvars)
     
    517503
    518504MPT_GP_DistMvPoly_t::MPT_GP_DistMvPoly_t(MPT_Node_pt tnode,
    519                                          MPT_GP_pt coeffs, int nvars,
     505                                         MPT_GP_pt coeffs, long nvars,
    520506                                         MPT_GP_Ordering_pt has_ordering,
    521507                                         MPT_GP_Ordering_pt should_ordering)
     
    532518}
    533519
    534 void MPT_GP_DistMvPoly_t::ExpVector(const void* monom, int* &expvector)
     520void MPT_GP_DistMvPoly_t::ExpVector(const void* monom, long* &expvector)
    535521{
    536522  MP_Sint32_t* ev = MP_SINT32_PT((MPT_ARG_PT(monom))[1]);
     
    538524  if (expvector != NULL)
    539525  {
    540     int i;
     526    long i;
    541527    for (i=0; i < _nvars; i++)
    542528      expvector[i] = ev[i];
    543529  }
    544530  else
    545     expvector = (int*) ev;
     531    expvector = (long*) ev;
    546532}
    547533
     
    556542}
    557543
    558 MPT_GP_Ordering_pt   MPT_GetGP_Ordering(MPT_Tree_pt o_tree, int nvars) 
     544MPT_GP_Ordering_pt   MPT_GetGP_Ordering(MPT_Tree_pt o_tree, long nvars) 
    559545{
    560546  if (o_tree != NULL)
     
    580566      case  MP_CcPolyOrdering_NegDegRevLex  : return GP_NegDegRevLexOrdering;
    581567      case  MP_CcPolyOrdering_NegDegLex     : return GP_NegDegLexOrdering;
    582       case  MP_CcPolyOrdering_Vector        : return GP_VectorOrdering;
    583568      case  MP_CcPolyOrdering_Matrix        : return GP_MatrixOrdering;
    584569      case  MP_CcPolyOrdering_IncComp       : return GP_IncrCompOrdering;
     
    670655}
    671656
    672 void MPT_GP_Ordering_t::BlockLimits(const void* block, int &low, int &high)
    673 {
    674   low = -1;
    675   high = -2;
    676 
    677   if (block == NULL) return;
     657long MPT_GP_Ordering_t::BlockLength(const void* block)
     658{
     659  long low = -1;
     660  long high = -2;
     661
     662  if (block == NULL) return -1;
    678663 
    679664  GP_OrderingType_t otype = OrderingType(block);
    680665  if (otype == GP_UnknownOrdering ||
    681666      otype == GP_ProductOrdering) 
    682     return;
     667    return -1;
    683668 
    684669  MPT_Tree_pt btree = MPT_TREE_PT(block);
     
    689674  {
    690675    MPT_Tree_pt ctree = MPT_TREE_PT(btree->args[1]);
    691     if (ctree == NULL) return;
     676    if (ctree == NULL) return -1;
    692677    if (ctree->node->type != MP_Sint32Type)
    693678      low = MP_SINT32_T(ctree->node->nvalue);
    694679    else if  (ctree->node->type != MP_Uint32Type)
    695680      low = MP_UINT32_T(ctree->node->nvalue);
    696     else return;
     681    else return -1;
    697682
    698683    ctree  = MPT_TREE_PT(btree->args[2]);
    699     if (ctree == NULL) return;
     684    if (ctree == NULL) return -1;
    700685    if (ctree->node->type != MP_Sint32Type)
    701686      high = MP_SINT32_T(ctree->node->nvalue);
    702687    else if  (ctree->node->type != MP_Uint32Type)
    703688      high = MP_UINT32_T(ctree->node->nvalue);
    704     else low = -1;
    705   }
     689    else return -1;
     690  }
     691
     692  return high - low;
    706693}
    707694
  • MP/MPT/MPT_GP.h

    r77cd73 r82dbf50  
    6464  MPT_GP_Iterator_t(MPT_Node_pt tnode);
    6565  MPT_GP_Iterator_t();
    66   virtual int N()                       {return _n;}
     66  virtual long N()                       {return _n;}
    6767  virtual void* Next();
    6868  virtual void  Reset(const void* data);
     
    7070
    7171private:
    72   int _i;
    73   int _n;
     72  long _i;
     73  long _n;
    7474  MPT_Arg_pt _args;
    7575  bool _dynamic;
     
    7979{
    8080public:
    81   MPT_GP_ValueIterator_t(MPT_Tree_pt tree, int vtype);
     81  MPT_GP_ValueIterator_t(MPT_Tree_pt tree, long vtype);
    8282  MPT_GP_ValueIterator_t();
    8383  void* Next();
     
    8585private:
    8686  MPT_Tree_pt _prototype;
    87   int _vtype;
    88 };
    89 bool MPT_GP_IsValueIterator(MPT_Tree_pt tree, int vtype = -1);
     87  long _vtype;
     88};
     89bool MPT_GP_IsValueIterator(MPT_Tree_pt tree, long vtype = -1);
    9090
    9191 
     
    9595MPT_GP_MvPoly_pt    MPT_GetGP_MvPoly(MPT_Node_pt tnode);
    9696MPT_GP_DistMvPoly_pt MPT_GetGP_DistMvPoly(MPT_Node_pt tnode);
    97 MPT_GP_Ordering_pt MPT_GetGP_Ordering(MPT_Node_pt tnode, int nvars);
     97MPT_GP_Ordering_pt MPT_GetGP_Ordering(MPT_Node_pt tnode, long nvars);
    9898
    9999/////////////////////////////////////////////////////////////////////
     
    104104class MPT_GP_Ordering_t : public GP_Ordering_t
    105105{
    106   friend MPT_GP_Ordering_pt MPT_GetGP_Ordering(MPT_Tree_pt tnode,int nvars);
     106  friend MPT_GP_Ordering_pt MPT_GetGP_Ordering(MPT_Tree_pt tnode,long nvars);
    107107 
    108108public:
     
    120120
    121121  // only relevant for blocks
    122   void BlockLimits(const void* block, int &low, int &high);
     122  long BlockLength(const void* block);
    123123
    124124protected:
     
    150150  GP_AtomEncoding_t AtomEncoding(const void* data);
    151151
    152   unsigned int      AtomUint(const void* data); 
    153   signed int        AtomSint(const void* data); 
    154152  unsigned long     AtomUlong(const void* data);
    155153  signed long       AtomSlong(const void* data);
     
    207205
    208206public:
    209   void MatrixDimension(const void* data, int &dx, int &dy)
     207  void MatrixDimension(long &dx, long &dy)
    210208   {dx = _dx; dy = _dy;}
    211209 
    212210protected:
    213211  MPT_GP_MatrixComp_t(MPT_Node_pt tnode, MPT_GP_pt elements,     
    214                       int dx, int dy)
     212                      long dx, long dy)
    215213      : MPT_GP_Comp_t(tnode, GP_MatrixCompType, elements)
    216214    {_dx = dx; _dy = dy;}
    217215
    218216private:
    219   int _dx;
    220   int _dy;
     217  long _dx;
     218  long _dy;
    221219};
    222220
     
    260258  virtual GP_RecMvPoly_pt   RecMvPoly()     {return NULL;}
    261259 
    262   int               NumberOfVars()  {return _nvars;}
     260  long              NumberOfVars()  {return _nvars;}
    263261  GP_Iterator_pt    VarNamesIterator()
    264262    {
     
    270268
    271269protected:
    272   MPT_GP_MvPoly_t(MPT_Node_pt tnode, MPT_GP_pt coeffs, int nvars);
    273   int _nvars;
     270  MPT_GP_MvPoly_t(MPT_Node_pt tnode, MPT_GP_pt coeffs, long nvars);
     271  long _nvars;
    274272  MPT_GP_Iterator_pt _vname_iterator;
    275273};
     
    292290    {_monom_iterator.Reset(data); return &(_monom_iterator);}
    293291  void*         Coeff(const void* monom);
    294   void          ExpVector(const void* monom, int* &expvector);
     292  void          ExpVector(const void* monom, long* &expvector);
    295293 
    296294  ~MPT_GP_DistMvPoly_t()
     
    301299
    302300protected:
    303   MPT_GP_DistMvPoly_t(MPT_Node_pt tnode, MPT_GP_pt coeffs, int nvars,
     301  MPT_GP_DistMvPoly_t(MPT_Node_pt tnode, MPT_GP_pt coeffs, long nvars,
    304302                      MPT_GP_Ordering_pt has_ordering,
    305303                      MPT_GP_Ordering_pt should_have_ordering);
  • MP/MPT/MPT_PutGP.cc

    r77cd73 r82dbf50  
    1212
    1313
    14 MP_Status_t MP_PutGP_Spec(MP_Link_pt link, GP_pt gp,
    15                           bool meta = TRUE, void* data = NULL)
     14MP_Status_t MP_PutGP_Object(MP_Link_pt link, GP_Object_t gp)
    1615{
    1716  switch(gp->Type())
    1817  {
    1918      case GP_AtomType:
    20         return MP_PutGP_AtomSpec(link, gp->Atom(), meta, data);
     19        return MP_PutGP_AtomPacket(link, gp->Atom(), data);
    2120       
    2221      case GP_PolyType:
     
    7069  {
    7170      case GP_SlongAtomEncoding:
    72       case GP_SintAtomEncoding:
    7371        mtype = MP_CmtProtoIMP_Sint32;
    7472        break;
    7573       
    76       case GP_UintAtomEncoding:
    7774      case GP_UlongAtomEncoding:
    7875        mtype = MP_CmtProtoIMP_Uint32;
     
    170167        return IMP_PutUint32(link, (MP_Uint32_t) gp->AtomUlong(data));
    171168       
    172       case GP_UintAtomEncoding:
    173         return IMP_PutUint32(link, (MP_Uint32_t) gp->AtomUint(data));
    174        
    175169      case GP_SlongAtomEncoding:
    176170        return IMP_PutSint32(link, (MP_Sint32_t) gp->AtomSlong(data));
    177171       
    178       case GP_SintAtomEncoding:
    179         return IMP_PutSint32(link, (MP_Sint32_t) gp->AtomSint(data));
    180 
    181172      case GP_FloatAtomEncoding:
    182173        return IMP_PutReal32(link, (MP_Real32_t) gp->AtomFloat(data));
     
    205196///
    206197/////////////////////////////////////////////////////////////////////
    207 MP_Status_t MP_PutGP_CompSpec((MP_Link_pt link, GP_Comp_pt gp,
     198
     199MP_Status_t MP_PutGP_CompSpec(MP_Link_pt link, GP_Comp_pt gp,
    208200                              bool meta = TRUE, void* data = NULL)
    209201{
     
    215207  MP_NumChild_t numchild = 0;
    216208 
    217 
    218209  if (ctype == GP_RationalCompType ||
    219210      ctype == GP_ComplexCompType)
     
    232223    ntype = MP_CommonOperatorType;
    233224  }
    234  
     225
    235226  switch (ctype)
    236227  {
     
    259250        cval = MP_CopMatrixDenseMatrix;
    260251        numannot++;
     252        break;
     253
     254      case GP_FreeModuleCompType:
     255        dict = MP_PolyDict;
     256        cval = MP_CopPolyFreeModule;
    261257        break;
    262258       
     
    270266  if (ctype == GP_MatrixCompType)
    271267  {
    272     int dx, dy;
    273     gp->
     268    long dx, dy;
     269    gp->MatrixDimension(dx, dy);
    274270   
    275271    ERR_CHK(MP_PutAnnotationPacket(link,
     
    282278                                        0, 2));
    283279   
    284     mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) , 0));
    285     mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) vlength, 0));
    286  
    287  
    288 }
     280    ERR_CHK(MP_PutSint32Packet(link, (MP_Uint32_t) , dx));
     281    ERR_CHK(MP_PutSint32Packet(link, (MP_Uint32_t) , dy));
     282  }
     283  return MP_Success;
     284}
     285 
     286
     287MP_Status_t MP_PutGP_CompData(MP_Link_pt link, GP_Atom_pt gp, void* data,
     288                              bool meta)
     289{
     290 
     291
    289292bool GP_Comp_t::IsCompDataOk(const void* data)
    290293{
     
    292295  GP_pt elements = Elements();
    293296  GP_CompType_t ctype = CompType();
    294   int i, n;
     297  long i, n;
    295298 
    296299 
     
    303306      case GP_MatrixCompType:
    304307      {
    305         int dx, dy;
     308        long dx, dy;
    306309        MatrixDimension(data, dx, dy);
    307310        if (dx < 0 || dy < 0) return false;
     
    391394  GP_pt coeff = Coeffs();
    392395
    393   int i, n;
     396  long i, n;
    394397  void* term;
    395398 
     
    478481  GP_pt             coeffs = Coeffs();
    479482  void*             monom;
    480   int i, n,j,       nvars  = NumberOfVars();
     483  long i, n,j,       nvars  = NumberOfVars();
    481484  GP_Iterator_pt    expvector = NULL;
    482485
     
    496499    if (type == GP_SparseDistMvPolyType)
    497500    {
    498       int m;
     501      long m;
    499502      void* exp;
    500503
     
    562565bool GP_Ordering_t::IsBlockOrderingOk(const void* block_ordering)
    563566{
    564   int low, high;
     567  long low, high;
    565568 
    566569  BlockLimits(block_ordering, low, high);
     
    587590}
    588591   
    589 bool GP_Ordering_t::IsOk(const int nvars)
     592bool GP_Ordering_t::IsOk(const long nvars)
    590593{
    591594  if (nvars <= 0) return false;
     
    613616      {
    614617        GP_Iterator_pt iter = BlockOrderingIterator();
    615         int i, n = 0, low, high;
     618        long i, n = 0, low, high;
    616619        bool found_zero=false, found_nvars=false;
    617620        void* block_ordering;
  • Singular/extra.cc

    r77cd73 r82dbf50  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: extra.cc,v 1.74 1998-11-12 13:06:11 Singular Exp $ */
     4/* $Id: extra.cc,v 1.75 1998-11-13 12:20:58 obachman Exp $ */
    55/*
    66* ABSTRACT: general interface to internals of Singular ("system" command)
     
    6565#include "silink.h"
    6666#include "mpsr.h"
     67#include "MPT_GP.h"
    6768
    6869#ifdef HAVE_DYNAMIC_LOADING
     
    918919        return TRUE;
    919920      }
     921      MPT_GP_pt gp_tree = MPT_GetGP(tree);
     922      if (gp_tree == NULL || ! gp_tree->IsOk(gp_tree))
     923      {
     924        WerrorS("gp error");
     925        return TRUE;
     926      }
     927      delete gp_tree;
    920928      MPT_DeleteTree(tree);
    921929      return FALSE;
  • Singular/mpsr_Get.cc

    r77cd73 r82dbf50  
    33****************************************/
    44
    5 /* $Id: mpsr_Get.cc,v 1.20 1998-11-09 15:43:03 obachman Exp $ */
     5/* $Id: mpsr_Get.cc,v 1.21 1998-11-13 12:20:59 obachman Exp $ */
    66/***************************************************************
    77 *
     
    524524  {
    525525    MPT_Tree_pt *tarray = (MPT_Tree_pt *) annot->value->args;
    526     if (tarray[0]->node->type == MP_Uint32Type &&
    527         tarray[1]->node->type == MP_Uint32Type)
    528     {
    529       row = MP_UINT32_T(tarray[0]->node->nvalue);
    530       col = MP_UINT32_T(tarray[1]->node->nvalue);
     526    if (tarray[0]->node->type == MP_Sint32Type &&
     527        tarray[1]->node->type == MP_Sint32Type)
     528    {
     529      row = MP_SINT32_T(tarray[0]->node->nvalue);
     530      col = MP_SINT32_T(tarray[1]->node->nvalue);
    531531    }
    532532  }
     
    645645  {
    646646    MPT_Tree_pt *tarray = (MPT_Tree_pt *) annot->value->args;
    647     if (tarray[0]->node->type == MP_Uint32Type &&
    648         tarray[1]->node->type == MP_Uint32Type)
    649     {
    650       row = MP_UINT32_T(tarray[0]->node->nvalue);
    651       col = MP_UINT32_T(tarray[1]->node->nvalue);
     647    if (tarray[0]->node->type == MP_Sint32Type &&
     648        tarray[1]->node->type == MP_Sint32Type)
     649    {
     650      row = MP_SINT32_T(tarray[0]->node->nvalue);
     651      col = MP_SINT32_T(tarray[1]->node->nvalue);
    652652    }
    653653  }
  • Singular/mpsr_Put.cc

    r77cd73 r82dbf50  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr_Put.cc,v 1.13 1998-10-21 10:25:54 krueger Exp $ */
     4/* $Id: mpsr_Put.cc,v 1.14 1998-11-13 12:20:59 obachman Exp $ */
    55
    66#define KAI
     
    203203                                      0,
    204204                                      2));
    205   mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) r, 0));
    206   mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) c, 0));
     205  mp_failr(MP_PutSint32Packet(link, (MP_Sint32_t) r, 0));
     206  mp_failr(MP_PutSint32Packet(link, (MP_Sint32_t) c, 0));
    207207
    208208  // And finally, we put the elments
     
    474474                                      MP_CopBasicList,
    475475                                      0, 2));
    476   mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) nrows, 0));
    477   mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) ncols, 0));
     476  mp_failr(MP_PutSint32Packet(link, (MP_Sint32_t) nrows, 0));
     477  mp_failr(MP_PutSint32Packet(link, (MP_Sint32_t) ncols, 0));
    478478
    479479  // And finally, we put the elments
  • Singular/mpsr_PutPoly.cc

    r77cd73 r82dbf50  
    33****************************************/
    44
    5 /* $Id: mpsr_PutPoly.cc,v 1.12 1998-04-21 10:59:29 obachman Exp $ */
     5/* $Id: mpsr_PutPoly.cc,v 1.13 1998-11-13 12:21:00 obachman Exp $ */
    66
    77/***************************************************************
     
    627627                                        MP_CopBasicList,
    628628                                        0, 2));
    629     mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) vlength, 0));
    630     mp_failr(MP_PutUint32Packet(link, (MP_Uint32_t) vlength, 0));
     629    mp_failr(MP_PutSint32Packet(link, (MP_Sint32_t) vlength, 0));
     630    mp_failr(MP_PutSint32Packet(link, (MP_Sint32_t) vlength, 0));
    631631    vlength *= vlength;
    632632  }
Note: See TracChangeset for help on using the changeset viewer.