tensor_eenv.hpp

Go to the documentation of this file.

#ifndef realroot_MPOLDSE_EENV_H
#define realroot_MPOLDSE_EENV_H
#include <realroot/sparse_monomials.hpp>

namespace mmx {

namespace tensor
{
  struct eenv
  { 
    void construct( int nvr_, int const * szs_, int const * vrs_, int * mem );
    static int msz( int nvr_ );
    int * szs();
    int * szs_data();
    int * str();
    int * vrs();
    void  cstr();
    void  cvrs();
    int * alloc( int nvr_ );
    void  dealloc();
    static eenv& copy(eenv& e, const eenv& b );
    static void  new_copy(eenv& e, const eenv& b );
    eenv& cdup();
    /*
    struct vr_t 
    { 
    int v,r; bool operator<( const vr_t& gv ) const { return v < gv.v; }; 
    bool operator==( int gv ) const { return v == gv; }; 
    vr_t() {};
    vr_t( int _v, int _r ) :v(_v), r(_r) {};
    };
    vr_t * gvr();
    const 
    vr_t * gvr() const;
    */
    
    int * data;
    
  public:
    int         nvr()  const;
    int const * szs()  const;
    int const * str()  const;
    int const * vrs()  const;
    int         sz ()  const;
    int sz ( int  v ) const;
    int st ( int  v ) const;
    int vr ( int lv ) const;
    bool hasvar( int& lv, int gv ) const;
    int  msz()          const;
    int localv( int i ) const { return i; };
    int vridx( int i )  const {
      int j; 
      for(j=0;j< nvr() && vrs()[j]!= i;j++) {}
      return j; };

    int mxvr() const { return vrs()[nvr()-1]; };
    int mnvr() const { return vrs()[0]; };
  

    eenv() : data(0) {};
    template<class C, class O> eenv( const sparse::monomial_seq<C,O>& mpl );
    eenv( int * data );
    eenv( int nvr_, int const * szs_ = 0, int const * vrs_  = 0, int * mem = 0 );
    eenv( const eenv& e );
    eenv& operator=( const eenv& e );
    void swap( eenv& e );
    ~eenv();
    static eenv  mrgvrs( const eenv& a, const eenv& b );
    /* new environement that can represent a and b  */
    static eenv  common( const eenv& a, const eenv& b ); 
    /* new environment (can represent a * b) */
    static eenv  mul   ( const eenv& a, const eenv& b );
    /* new environment that can represent. diff(b,lv) */
    static eenv  diff( const eenv& b, int lv );
    bool operator<( const eenv& b ) const;
    
    static bool vmap( int * vmap, const eenv& o, const eenv&  i );
    static bool oaddress( const eenv&  oenv, unsigned * osupp,
              const eenv&  ienv, unsigned * isupp = 0 ,unsigned nsp = 0 );
    friend std::ostream& operator<<( std::ostream& o, const eenv& env );
    //friend std::ostream& operator<<( std::ostream& o, const vr_t& v );
        static bool equiv( const eenv& a, const eenv& b );
    static bool equal( const eenv& a, const eenv& b );
    bool operator==( const eenv& a ) const;
    bool operator!=( const eenv& a ) const;
    static bool subset( const eenv& a, const eenv& b );
    static eenv elevation( const eenv& a, const eenv& b );
    void vswap( int * perm );
    static eenv rewrite( const eenv&o, const eenv& i );
  };
}

} //namespace mmx

#include "tensor_eenv_fcts.hpp"
#include "tensor_eenv_loops.hpp"

#endif