Changeset 07cbfe in git


Ignore:
Timestamp:
Nov 10, 1998, 7:58:10 AM (26 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'c7af8613769b29c741d6c338945669719f1fc4f8')
Children:
9e2789b43fe9b89b5f5815b92ab89b5a03d8754e
Parents:
0d67d1a21775b2276749beabac94d42e5e4915b5
Message:
* as we go along


git-svn-id: file:///usr/local/Singular/svn/trunk@2653 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
MP/MPT
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • MP/MPT/GP.h

    r0d67d1 r07cbfe  
    8585  virtual void* Next()                  = 0;
    8686  virtual void  Reset(const void* data) = 0;
    87   virtual ~GP_Iterator_t()              = 0;
     87  virtual ~GP_Iterator_t() {}
     88 
     89     
    8890} * GP_Iterator_pt;
    8991
     
    206208} GP_PolyType_t;
    207209
    208 class GP_Poly_t : public GP_t
     210class GP_Poly_t : virtual public GP_t
    209211{
    210212public:
  • MP/MPT/GP_IsOk.cc

    r0d67d1 r07cbfe  
    363363      ExpVector(monom, evector);
    364364     
    365       if (evector != NULL)
    366       {
    367         for (j = 0; j<nvars; j++)
    368         {
    369           if (evector[j] < 0) return false;
    370         }
     365      if (evector == NULL) return NULL;
     366      for (j = 0; j<nvars; j++)
     367      {
     368        if (evector[j] < 0) return false;
    371369      }
    372370    }
  • MP/MPT/MPT.h

    r0d67d1 r07cbfe  
    357357
    358358extern MP_Boolean_t MPT_IsTrueProtoTypeSpec(MPT_Tree_pt typespec);
     359inline MPT_Tree_pt MPT_TrueProtoAnnotValue(MPT_Node_pt node)
     360{
     361  MPT_Tree_pt ptree = MPT_ProtoAnnotValue(node);
     362  if (ptree != NULL && MPT_IsTrueProtoTypeSpec(ptree))
     363    return ptree;
     364 
     365  return NULL;
     366}
    359367
    360368extern void*       IMP_MemAlloc0Fnc(size_t size);
  • MP/MPT/MPT_GP.cc

    r0d67d1 r07cbfe  
    1515///
    1616/////////////////////////////////////////////////////////////////////
    17 MPT_GP_Iterator_t::MPT_GP_Iterator_t(MPT_Tree_pt typespec)
    18 {
    19   MPT_Assume(typespec != NULL &&
    20              (typespec->node->type == MP_CommonOperatorType ||
    21               typespec->node->type == MP_CommonMetaOperatorType));
    22 
    23   if (typespec->node->type == MP_CommonMetaOperatorType &&
    24       typespec->node->numchild == 0)
     17MPT_GP_Iterator_t::MPT_GP_Iterator_t(MPT_Node_pt tnode)
     18{
     19  MPT_Assume(tnode != NULL &&
     20             (tnode->type == MP_CommonOperatorType ||
     21              tnode->type == MP_CommonMetaOperatorType));
     22
     23  if (tnode->type == MP_CommonMetaOperatorType &&
     24      tnode->numchild == 0)
    2525  {
    2626    _n = -1;
     
    2929  else
    3030  {
    31     _n = typespec->node->numchild;
     31    _n = tnode->numchild;
    3232    _dynamic = false;
    3333  }
    3434
    3535  _i = _n+1;
     36  _args = NULL;
     37}
     38
     39MPT_GP_Iterator_t::MPT_GP_Iterator_t()
     40{
     41  _n = -1;
     42  _dynamic = false;
     43  _i = -2;
    3644  _args = NULL;
    3745}
     
    5967}
    6068
    61 bool MPT_GP_IsIntIterator(MPT_Tree_pt tree)
     69bool MPT_GP_IsValueIterator(MPT_Tree_pt tree, int vtype)
    6270{
    6371  if (tree == NULL || tree->node->type != MP_CommonOperatorType)
    6472    return false;
    65   MPT_Tree_pt proto = MPT_ProtoAnnotValue(tree->node);
     73  MPT_Tree_pt proto = MPT_TrueProtoAnnotValue(tree->node);
     74
    6675  if (proto != NULL)
    6776  {
    68     if (proto->node->type == MP_CommonMetaType &&
    69         proto->node->dict == MP_ProtoDict &&
    70         MP_IsFixedIntegerType(MP_CmtProto_2_MPType
    71                               (MP_COMMON_T(proto->node->nvalue))))
     77    if (vtype < 0 ||
     78        (proto->node->type == MP_CommonMetaType &&
     79         proto->node->dict == MP_ProtoDict &&
     80         vtype == MP_CmtProto_2_MPType(MP_COMMON_T(proto->node->nvalue))))
    7281      return true;
    73     else if (proto->node->type != MP_CommonMetaType &&
    74              proto->node->dict == MP_NumberDict &&
    75              MP_COMMON_T(proto->node->nvalue) !=  MP_CmtNumberInteger)
     82    else
    7683      return false;
    7784  }
    78   int nc = tree->node->numchild, i;
    79   for (i=0; i<nc; i++)
    80   {
    81     if (! MP_IsFixedIntegerType(
    82       MP_COMMON_T(MPT_TREE_PT(tree->args[i])->node->type)))
    83       return false;
     85  if (vtype >= 0)
     86  {
     87    int nc = tree->node->numchild, i;
     88    MPT_Arg_pt args;
     89 
     90    for (i=0; i<nc; i++)
     91    {
     92      if (vtype != MP_COMMON_T(MPT_TREE_PT(tree->args[i])->node->type))
     93        return false;
     94    }
    8495  }
    8596  return true;
    8697}
    87  
    88 
    89 MPT_GP_IntIterator_t::MPT_GP_IntIterator_t(MPT_Tree_pt tree)
    90     : MPT_GP_Iterator_t(NULL)
    91 {
    92   MPT_Assume(MPT_GP_IsIntIterator(tree));
    93   _prototype = MPT_ProtoAnnotValue(tree->node);
    94 }
    95 
    96 void* MPT_GP_IntIterator_t::Next()
     98
     99MPT_GP_ValueIterator_t::MPT_GP_ValueIterator_t(MPT_Tree_pt tree, int vtype)
     100    : MPT_GP_Iterator_t(tree->node)
     101{
     102  MPT_Assume(MPT_GP_IsValueIterator(tree, vtype));
     103  _prototype = MPT_TrueProtoAnnotValue(tree->node);
     104  _vtype = vtype;
     105}
     106
     107MPT_GP_ValueIterator_t::MPT_GP_ValueIterator_t()
     108    : MPT_GP_Iterator_t()
     109{
     110  _vtype = -1;
     111  _prototype = NULL;
     112}
     113
     114void* MPT_GP_ValueIterator_t::Next()
    97115{
    98116  void* arg = MPT_GP_Iterator_t::Next();
     
    109127/////////////////////////////////////////////////////////////////////
    110128
    111 MPT_GP_pt MPT_GetGP(MPT_Tree_pt typespec)
    112 {
    113   if (typespec != NULL)
    114   {
    115     MPT_GP_pt gp;
    116     if ((gp = MPT_GetGP_Atom(typespec)) != NULL) return gp;
    117     if ((gp = MPT_GetGP_Comp(typespec)) != NULL) return gp;
    118     if ((gp = MPT_GetGP_Poly(typespec)) != NULL) return gp;
    119   }
     129MPT_GP_pt MPT_GetGP(MPT_Node_pt tnode)
     130{
     131  MPT_Assume(tnode != NULL);
     132  MPT_GP_pt gp;
     133  if ((gp = MPT_GetGP_Atom(tnode)) != NULL) return gp;
     134  if ((gp = MPT_GetGP_Comp(tnode)) != NULL) return gp;
     135  if ((gp = MPT_GetGP_Poly(tnode)) != NULL) return gp;
    120136  return NULL;
     137}
     138
     139MPT_GP_pt MPT_GetGP(MPT_Tree_pt tree)
     140{
     141  if (tree == NULL) return NULL;
     142  return MPT_GetGP(tree->node);
    121143}
    122144
     
    157179}
    158180
    159 MPT_GP_Atom_pt MPT_GetGP_Atom(MPT_Tree_pt typespec)
    160 {
    161   if (typespec == NULL) return NULL;
    162  
    163   MPT_Node_pt node = typespec->node;
    164   MP_NodeType_t ntype = node->type;
     181MPT_GP_Atom_pt MPT_GetGP_Atom(MPT_Node_pt tnode)
     182{
     183  if (tnode == NULL) return NULL;
     184 
     185  MP_NodeType_t ntype = tnode->type;
    165186  GP_AtomType_t atype;
    166187  MPT_Arg_t modulus = NULL;
    167   MPT_Tree_pt _typespec = NULL;
    168  
    169   if (ntype == MP_CommonMetaType && node->dict == MP_ProtoDict)
    170   {
    171     _typespec = typespec;
    172     ntype = MP_CmtProto_2_MPType(MP_COMMON_T(node->nvalue));
     188  MPT_Node_pt _tnode = NULL;
     189 
     190  if (ntype == MP_CommonMetaType && tnode->dict == MP_ProtoDict)
     191  {
     192    _tnode = tnode;
     193    ntype = MP_CmtProto_2_MPType(MP_COMMON_T(tnode->nvalue));
    173194  }
    174195 
     
    178199    atype = GP_IntegerAtomType;
    179200
    180     MPT_Tree_pt mtree = MPT_AnnotValue(typespec->node,
     201    MPT_Tree_pt mtree = MPT_AnnotValue(tnode,
    181202                                       MP_NumberDict, MP_AnnotNumberModulos);
    182203    if (mtree != NULL && ntype == mtree->node->type)
     
    192213    return NULL;
    193214 
    194   return new MPT_GP_Atom_t(_typespec, atype,
     215  return new MPT_GP_Atom_t(_tnode, atype,
    195216                           MP_Type_2_GP_AtomEncoding(ntype),
    196217                           modulus);
    197218}
    198 
     219 
    199220GP_AtomEncoding_t MPT_GP_Atom_t::AtomEncoding(const void* data)
    200221{
    201222  if (_aencoding != GP_DynamicAtomEncoding) return _aencoding;
    202   MPT_Assume(_typespec == NULL && data != NULL);
     223  MPT_Assume(_tnode == NULL && data != NULL);
    203224  return MP_Type_2_GP_AtomEncoding(((MPT_Tree_pt) data)->node->type);
    204225}
     
    209230
    210231  return (unsigned int)
    211     MP_UINT8_T(_typespec != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
     232    MP_UINT8_T(_tnode != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
    212233}
    213234signed int MPT_GP_Atom_t::AtomSint(const void* data)
     
    216237
    217238  return (int)
    218     MP_SINT8_T((_typespec!=NULL ? data : ((MPT_Tree_pt) data)->node->nvalue));
     239    MP_SINT8_T((_tnode!=NULL ? data : ((MPT_Tree_pt) data)->node->nvalue));
    219240}
    220241unsigned long MPT_GP_Atom_t::AtomUlong(const void* data)
     
    223244
    224245  return (unsigned long)
    225     (_typespec != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
     246    (_tnode != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
    226247}
    227248signed long MPT_GP_Atom_t::AtomSlong(const void* data)
     
    230251
    231252  return (long)
    232     (_typespec != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
     253    (_tnode != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
    233254}
    234255float MPT_GP_Atom_t::AtomFloat(const void* data)
    235256{
    236257  MPT_Assume(AtomEncoding(data) == GP_FloatAtomEncoding);
    237   if (_typespec != NULL)
     258  if (_tnode != NULL)
    238259    return *((float*) &data);
    239260  return *((float*) &(((MPT_Tree_pt) data)->node->nvalue));
     
    244265
    245266  return (double)
    246     MP_REAL64_T((_typespec!=NULL ? data : ((MPT_Tree_pt) data)->node->nvalue));
     267    MP_REAL64_T((_tnode!=NULL ? data : ((MPT_Tree_pt) data)->node->nvalue));
    247268}
    248269const void* MPT_GP_Atom_t::AtomGmpApInt(const void* data)
     
    250271  MPT_Assume(AtomEncoding(data) == GP_GmpApIntAtomEncoding);
    251272
    252   return (_typespec != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
     273  return (_tnode != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
    253274}
    254275const void* MPT_GP_Atom_t::AtomPariApInt(const void* data)
     
    256277  MPT_Assume(AtomEncoding(data) == GP_PariApIntAtomEncoding);
    257278
    258   return (_typespec != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
     279  return (_tnode != NULL ? data : ((MPT_Tree_pt) data)->node->nvalue);
    259280}
    260281
     
    301322}
    302323
    303 MPT_GP_Comp_pt MPT_GetGP_Comp(MPT_Tree_pt typespec)
    304 {
    305   if (typespec == NULL) return NULL;
    306  
     324MPT_GP_Comp_pt MPT_GetGP_Comp(MPT_Node_pt tnode)
     325{
     326  if (tnode == NULL) return NULL;
    307327  GP_CompType_t comptype
    308     =   MP_TypeDictOp_2_GP_CompType(typespec->node->type,
    309                                     typespec->node->dict,
    310                                     MP_COMMON_T(typespec->node->nvalue));
     328    =   MP_TypeDictOp_2_GP_CompType(tnode->type, tnode->dict,
     329                                    MP_COMMON_T(tnode->nvalue));
    311330 
    312331  if (comptype == GP_UnknownCompType) return NULL;
    313332 
    314   MPT_GP_pt elements = MPT_GetGP(MPT_ProtoAnnotValue(typespec->node));
     333  MPT_GP_pt elements = MPT_GetGP(MPT_ProtoAnnotValue(tnode));
    315334 
    316335  if (elements == NULL)
     
    352371  else if (comptype == GP_MatrixCompType)
    353372  {
    354     MPT_Tree_pt tree = MPT_AnnotValue(typespec->node,
     373    MPT_Tree_pt tree = MPT_AnnotValue(tnode,
    355374                                      MP_MatrixDict,
    356375                                      MP_AnnotMatrixDimension);
     
    375394      dy = MP_UINT32_T(ctree->node->nvalue);
    376395    else goto null_return;
    377     return new MPT_GP_MatrixComp_t(typespec, elements, dx, dy);
    378   }
    379   return new MPT_GP_Comp_t(typespec, comptype, elements);
    380   return NULL;
     396    return new MPT_GP_MatrixComp_t(tnode, elements, dx, dy);
     397  }
     398  return new MPT_GP_Comp_t(tnode, comptype, elements);
    381399 
    382400  null_return:
     
    390408///
    391409/////////////////////////////////////////////////////////////////////
    392 MPT_GP_Poly_pt MPT_GetGP_Poly(MPT_Tree_pt typespec)
    393 {
    394   return MPT_GetGP_MvPoly(typespec);
     410MPT_GP_Poly_pt MPT_GetGP_Poly(MPT_Node_pt tnode)
     411{
     412  return MPT_GetGP_MvPoly(tnode);
    395413}
    396414
    397415bool MPT_GP_Poly_t::IsFreeModuleVector()
    398416{
    399   if (MPT_Annot(_typespec->node,
     417  if (MPT_Annot(_tnode,
    400418                MP_PolyDict,
    401419                MP_AnnotPolyModuleVector) != NULL)
     
    404422}
    405423
    406 MPT_GP_MvPoly_pt MPT_GetGP_MvPoly(MPT_Tree_pt typespec)
    407 {
    408   return MPT_GetGP_DistMvPoly(typespec);
    409 }
    410 
    411 MPT_GP_MvPoly_t::MPT_GP_MvPoly_t(MPT_Tree_pt typespec,
     424MPT_GP_MvPoly_pt MPT_GetGP_MvPoly(MPT_Node_pt tnode)
     425{
     426  return MPT_GetGP_DistMvPoly(tnode);
     427}
     428
     429MPT_GP_MvPoly_t::MPT_GP_MvPoly_t(MPT_Node_pt tnode,
    412430                                 MPT_GP_pt coeffs,
    413431                                 int nvars)
    414     : MPT_GP_Poly_t(typespec, coeffs)
     432    : MPT_GP_Poly_t(tnode, coeffs)
    415433{
    416434  _nvars = nvars;
    417   MPT_Tree_pt vtree = MPT_AnnotValue(typespec->node,
     435  MPT_Tree_pt vtree = MPT_AnnotValue(tnode,
    418436                                     MP_PolyDict,
    419437                                     MP_AnnotPolyVarNames);
    420438
    421   if (vtree != NULL && vtree->node->type == MP_CommonOperatorType)
    422   {
    423     // Hmm ... should check for strings
    424     _vname_iterator = new MPT_GP_Iterator_t(NULL);
    425     _vname_iterator->Reset(vtree);
     439  if (vtree != NULL && MPT_GP_IsValueIterator(vtree, MP_StringType))
     440  {
     441    _vname_iterator = new MPT_GP_ValueIterator_t(vtree, MP_StringType);
     442    _vname_iterator->Reset(vtree->args);
    426443  }
    427444  else
     
    430447
    431448static GP_DistMvPolyType_t
    432 MPT_GetGP_DistMvPolyType(MPT_Tree_pt typespec,
     449MPT_GetGP_DistMvPolyType(MPT_Node_pt tnode,
    433450                         MPT_GP_pt &coeffs,
    434451                         int &nvars)
    435452{
    436   MPT_Assume(typespec != NULL);
     453  MPT_Assume(tnode != NULL);
    437454  MPT_Node_pt node;
    438455  MPT_Tree_pt val;
     
    440457 
    441458  // a DDP consists of monoms
    442   if ((val =  MPT_ProtoAnnotValue(typespec->node)) == NULL)
     459  if ((val =  MPT_ProtoAnnotValue(tnode)) == NULL)
    443460    return GP_UnknownDistMvPolyType;
    444461 
     
    473490}
    474491 
    475 MPT_GP_DistMvPoly_pt MPT_GetGP_DistMvPoly(MPT_Tree_pt typespec)
    476 {
    477   if (typespec == NULL) return NULL;
     492MPT_GP_DistMvPoly_pt MPT_GetGP_DistMvPoly(MPT_Node_pt tnode)
     493{
     494  if (tnode == NULL) return NULL;
    478495
    479496  MPT_GP_pt coeffs;
    480497  int nvars;
    481498 
    482   if (MPT_GetGP_DistMvPolyType(typespec, coeffs, nvars)
     499  if (MPT_GetGP_DistMvPolyType(tnode, coeffs, nvars)
    483500      != GP_DenseDistMvPolyType)
    484501    return NULL;
    485502
    486503  return new
    487     MPT_GP_DistMvPoly_t(typespec, coeffs, nvars,
     504    MPT_GP_DistMvPoly_t(tnode, coeffs, nvars,
    488505                        MPT_GetGP_Ordering(
    489                           MPT_AnnotValue(typespec->node,
     506                          MPT_AnnotValue(tnode,
    490507                                         MP_PolyDict,
    491508                                         MP_AnnotPolyOrdering),
    492509                          nvars),
    493510                        MPT_GetGP_Ordering(
    494                           MPT_AnnotValue(typespec->node,
     511                          MPT_AnnotValue(tnode,
    495512                                         MP_PolyDict,
    496513                                         MP_AnnotShouldHavePolyOrdering),
     
    499516}
    500517
    501 MPT_GP_DistMvPoly_t::MPT_GP_DistMvPoly_t(MPT_Tree_pt typespec,
     518MPT_GP_DistMvPoly_t::MPT_GP_DistMvPoly_t(MPT_Node_pt tnode,
    502519                                         MPT_GP_pt coeffs, int nvars,
    503520                                         MPT_GP_Ordering_pt has_ordering,
    504521                                         MPT_GP_Ordering_pt should_ordering)
    505     : MPT_GP_MvPoly_t(typespec, coeffs, nvars), _monom_iterator(typespec)
     522    : MPT_GP_MvPoly_t(tnode, coeffs, nvars), _monom_iterator(tnode)
    506523{
    507524  _has_ordering = has_ordering;
     
    535552/////////////////////////////////////////////////////////////////////
    536553MPT_GP_Ordering_t::MPT_GP_Ordering_t(MPT_Tree_pt otree)
    537     : _block_iterator(NULL),
    538       _weights_iterator(NULL),
    539       _block_weights_iterator(NULL)
    540554{
    541555  _otree = otree;
     
    577591GP_OrderingType_t MPT_GP_Ordering_t::OrderingType()
    578592{
    579  
    580593  if (MPT_IsNode(_otree->node, MP_CommonConstantType, MP_PolyDict))
    581594    return
     
    618631                                     MP_PolyDict,
    619632                                     MP_AnnotPolyWeights);
    620   if (! MPT_GP_IsIntIterator(wtree)) return NULL;
    621   _weights_iterator = MPT_GP_IntIterator_t(wtree);
     633  if (wtree == NULL || ! MPT_GP_IsValueIterator(wtree, MP_Sint32Type))
     634    return NULL;
     635  _weights_iterator = MPT_GP_ValueIterator_t(wtree, MP_Sint32Type);
    622636  return &(_weights_iterator);
    623637}
     
    638652                                     MP_AnnotPolyWeights);
    639653
    640   if (MPT_GP_IsIntIterator(btree) == NULL) return NULL;
    641   _block_weights_iterator = MPT_GP_IntIterator_t(btree);
     654  if (btree == NULL || ! MPT_GP_IsValueIterator(btree, MP_Sint32Type))
     655    return NULL;
     656  _block_weights_iterator = MPT_GP_ValueIterator_t(btree, MP_Sint32Type);
    642657 
    643658  return &(_block_weights_iterator);
     
    650665  if (otype != GP_ProductOrdering) return NULL;
    651666 
    652   _block_iterator =  MPT_GP_Iterator_t(NULL);
    653   _block_iterator.Reset(_otree);
     667  _block_iterator =  MPT_GP_Iterator_t(_otree->node);
     668  _block_iterator.Reset(_otree->args);
    654669  return &(_block_iterator);
    655670}
  • MP/MPT/MPT_GP.h

    r0d67d1 r07cbfe  
    3333class MPT_Top_t
    3434{
    35 protected:
    36   void * operator new(size_t size)
     35public:
     36  void* operator new(size_t size)
    3737    {return IMP_MemAllocFnc(size);}
    38 public:
    3938  void operator delete(void* p, size_t s)
    4039    {IMP_MemFreeFnc(p,s);}
     
    5352
    5453protected:
    55   MPT_GP_t()                         {_typespec = NULL;}
    56   MPT_GP_t(MPT_Tree_pt typespec)     {_typespec = typespec;}
    57   MPT_Tree_pt _typespec;
    58 };
    59 MPT_GP_pt MPT_GetGP(MPT_Tree_pt typespec);
    60 
    61 typedef class MPT_GP_Iterator_t : public GP_Iterator_t
    62 {
    63 public:
    64   MPT_GP_Iterator_t(MPT_Tree_pt typespec);
     54  MPT_GP_t()                         {_tnode = NULL;}
     55  MPT_GP_t(MPT_Node_pt tnode)     {_tnode = tnode;}
     56  MPT_Node_pt _tnode;
     57};
     58MPT_GP_pt MPT_GetGP(MPT_Node_pt tnode);
     59MPT_GP_pt MPT_GetGP(MPT_Tree_pt tree);
     60
     61typedef class MPT_GP_Iterator_t : public GP_Iterator_t, public MPT_Top_t
     62{
     63public:
     64  MPT_GP_Iterator_t(MPT_Node_pt tnode);
     65  MPT_GP_Iterator_t();
    6566  virtual int N()                       {return _n;}
    6667  virtual void* Next();
    6768  virtual void  Reset(const void* data);
     69  ~MPT_GP_Iterator_t() {}
    6870
    6971private:
     
    7476} * MPT_GP_Iterator_pt;
    7577
    76 typedef class MPT_GP_IntIterator_t : public MPT_GP_Iterator_t
    77 {
    78 public:
    79   MPT_GP_IntIterator_t(MPT_Tree_pt tree);
     78typedef class MPT_GP_ValueIterator_t : public MPT_GP_Iterator_t
     79{
     80public:
     81  MPT_GP_ValueIterator_t(MPT_Tree_pt tree, int vtype);
     82  MPT_GP_ValueIterator_t();
    8083  void* Next();
    8184
    8285private:
    8386  MPT_Tree_pt _prototype;
    84 };
    85 
    86 
    87  
    88 MPT_GP_Atom_pt      MPT_GetGP_Atom(MPT_Tree_pt typespec);
    89 MPT_GP_Comp_pt      MPT_GetGP_Comp(MPT_Tree_pt typespec);
    90 MPT_GP_Poly_pt      MPT_GetGP_Poly(MPT_Tree_pt typespec);
    91 MPT_GP_MvPoly_pt    MPT_GetGP_MvPoly(MPT_Tree_pt typespec);
    92 MPT_GP_DistMvPoly_pt MPT_GetGP_DistMvPoly(MPT_Tree_pt typespec);
    93 MPT_GP_Ordering_pt MPT_GetGP_Ordering(MPT_Tree_pt typespec, int nvars);
     87  int _vtype;
     88};
     89bool MPT_GP_IsValueIterator(MPT_Tree_pt tree, int vtype = -1);
     90
     91 
     92MPT_GP_Atom_pt      MPT_GetGP_Atom(MPT_Node_pt tnode);
     93MPT_GP_Comp_pt      MPT_GetGP_Comp(MPT_Node_pt tnode);
     94MPT_GP_Poly_pt      MPT_GetGP_Poly(MPT_Node_pt tnode);
     95MPT_GP_MvPoly_pt    MPT_GetGP_MvPoly(MPT_Node_pt tnode);
     96MPT_GP_DistMvPoly_pt MPT_GetGP_DistMvPoly(MPT_Node_pt tnode);
     97MPT_GP_Ordering_pt MPT_GetGP_Ordering(MPT_Node_pt tnode, int nvars);
    9498
    9599/////////////////////////////////////////////////////////////////////
     
    100104class MPT_GP_Ordering_t : public GP_Ordering_t
    101105{
    102   friend MPT_GP_Ordering_pt MPT_GetGP_Ordering(MPT_Tree_pt typespec,int nvars);
     106  friend MPT_GP_Ordering_pt MPT_GetGP_Ordering(MPT_Tree_pt tnode,int nvars);
    103107 
    104108public:
     
    124128  MPT_Tree_pt _otree;
    125129  MPT_GP_Iterator_t _block_iterator;
    126   MPT_GP_IntIterator_t _weights_iterator;
    127   MPT_GP_IntIterator_t _block_weights_iterator;
     130  MPT_GP_ValueIterator_t _weights_iterator;
     131  MPT_GP_ValueIterator_t _block_weights_iterator;
    128132};
    129133     
     
    136140class MPT_GP_Atom_t : public GP_Atom_t, public MPT_GP_t
    137141{
    138   friend MPT_GP_Atom_pt MPT_GetGP_Atom(MPT_Tree_pt typespec);
    139   friend MPT_GP_Comp_pt MPT_GetGP_Comp(MPT_Tree_pt typespec);
     142  friend MPT_GP_Atom_pt MPT_GetGP_Atom(MPT_Node_pt tnode);
     143  friend MPT_GP_Comp_pt MPT_GetGP_Comp(MPT_Node_pt tnode);
    140144
    141145public:
     
    156160
    157161protected:
    158   MPT_GP_Atom_t(MPT_Tree_pt typespec,
     162  MPT_GP_Atom_t(MPT_Node_pt tnode,
    159163                GP_AtomType_t atype, GP_AtomEncoding_t aencoding,
    160164                MPT_Arg_t modulus = NULL)
    161       : MPT_GP_t(typespec)
     165      : MPT_GP_t(tnode)
    162166    {_atype = atype; _aencoding = aencoding; _modulus = modulus;}
    163167
     
    175179class MPT_GP_Comp_t : public GP_Comp_t, public MPT_GP_t
    176180{
    177   friend MPT_GP_Comp_pt MPT_GetGP_Comp(MPT_Tree_pt typespec);
    178 
    179 protected:
    180   MPT_GP_Comp_t(MPT_Tree_pt typespec, GP_CompType_t ctype, MPT_GP_pt elements)
    181       : _iterator(typespec), MPT_GP_t(typespec)
     181  friend MPT_GP_Comp_pt MPT_GetGP_Comp(MPT_Node_pt tnode);
     182
     183protected:
     184  MPT_GP_Comp_t(MPT_Node_pt tnode, GP_CompType_t ctype, MPT_GP_pt elements)
     185      : _iterator(tnode), MPT_GP_t(tnode)
    182186    {_ctype = ctype; _elements = elements;}
    183187 
     
    200204class MPT_GP_MatrixComp_t : public MPT_GP_Comp_t
    201205{
    202   friend MPT_GP_Comp_pt MPT_GetGP_Comp(MPT_Tree_pt typespec);
     206  friend MPT_GP_Comp_pt MPT_GetGP_Comp(MPT_Node_pt tnode);
    203207
    204208public:
     
    207211 
    208212protected:
    209   MPT_GP_MatrixComp_t(MPT_Tree_pt typespec, MPT_GP_pt elements,     
     213  MPT_GP_MatrixComp_t(MPT_Node_pt tnode, MPT_GP_pt elements,     
    210214                      int dx, int dy)
    211       : MPT_GP_Comp_t(typespec, GP_MatrixCompType, elements)
     215      : MPT_GP_Comp_t(tnode, GP_MatrixCompType, elements)
    212216    {_dx = dx; _dy = dy;}
    213217
     
    224228class MPT_GP_Poly_t : public virtual GP_Poly_t, public MPT_GP_t
    225229{
    226   friend MPT_GP_Poly_pt MPT_GetGP_Poly(MPT_Tree_pt typespec);
    227 
    228 protected:
    229   MPT_GP_Poly_t(MPT_Tree_pt typespec, MPT_GP_pt coeffs)
    230       : MPT_GP_t(typespec)
     230  friend MPT_GP_Poly_pt MPT_GetGP_Poly(MPT_Node_pt tnode);
     231
     232protected:
     233  MPT_GP_Poly_t(MPT_Node_pt tnode, MPT_GP_pt coeffs)
     234      : MPT_GP_t(tnode)
    231235    {_coeffs = coeffs;}
    232236  MPT_GP_pt _coeffs;
    233237
    234238public:
     239  GP_Poly_pt            Poly()      {return this;}
    235240  virtual GP_UvPoly_pt  UvPoly()    {return NULL;}
    236241  virtual GP_MvPoly_pt  MvPoly()    {return NULL;}
     
    248253class MPT_GP_MvPoly_t : public virtual GP_MvPoly_t, public MPT_GP_Poly_t
    249254{
    250   friend MPT_GP_MvPoly_pt MPT_GetGP_MvPoly(MPT_Tree_pt typespec);
     255  friend MPT_GP_MvPoly_pt MPT_GetGP_MvPoly(MPT_Node_pt tnode);
    251256 
    252257public:
     
    258263  GP_Iterator_pt    VarNamesIterator()
    259264    {
    260       if (_vname_iterator != NULL) _vname_iterator->Reset(_typespec);
     265      if (_vname_iterator != NULL) _vname_iterator->Reset(_tnode);
    261266      return (GP_Iterator_pt) _vname_iterator;
    262267    }
     
    265270
    266271protected:
    267   MPT_GP_MvPoly_t(MPT_Tree_pt typespec, MPT_GP_pt coeffs, int nvars);
     272  MPT_GP_MvPoly_t(MPT_Node_pt tnode, MPT_GP_pt coeffs, int nvars);
    268273  int _nvars;
    269274  MPT_GP_Iterator_pt _vname_iterator;
     
    275280  : public virtual GP_DistMvPoly_t, public MPT_GP_MvPoly_t
    276281{
    277   friend MPT_GP_DistMvPoly_pt MPT_GetGP_DistMvPoly(MPT_Tree_pt typespec);
     282  friend MPT_GP_DistMvPoly_pt MPT_GetGP_DistMvPoly(MPT_Node_pt tnode);
    278283 
    279284public:
     
    296301
    297302protected:
    298   MPT_GP_DistMvPoly_t(MPT_Tree_pt typespec, MPT_GP_pt coeffs, int nvars,
     303  MPT_GP_DistMvPoly_t(MPT_Node_pt tnode, MPT_GP_pt coeffs, int nvars,
    299304                      MPT_GP_Ordering_pt has_ordering,
    300305                      MPT_GP_Ordering_pt should_have_ordering);
  • MP/MPT/Makefile.in

    r0d67d1 r07cbfe  
    8080        $(RANLIB) $(libdir)/libMPT.a
    8181        $(INSTALL_DATA) MPT.h $(includedir)
     82        $(INSTALL_DATA) MPT_GP.h $(includedir)
     83        $(INSTALL_DATA) GP.h $(includedir)
    8284        -chmod a-x $(libdir)/libMPT.a $(includedir)/MPT.h
    8385
Note: See TracChangeset for help on using the changeset viewer.