tarray.hxx

Go to the documentation of this file.

#ifndef NUMCXX_TARRAY_H
#define NUMCXX_TARRAY_H
#include <ostream>
#include <typeinfo>
#include <memory>
#include <stdexcept> 
#include <functional> 
#include "expression.ixx"


namespace numcxx
{
  template<typename T> class TArray;



  template<typename T>
  inline std::ostream & operator << (std::ostream & s, TArray<T> &A);

  template<typename T> class TArray
  {
  public:

    typedef T value_type;

    T & operator()(const index i0)  { return _data[_idx(i0)];};
    const T & operator()(const index i0) const  { return _data[_idx(i0)];};

    T & operator()(const index i0, const index i1)  { return _data[_idx(i0,i1)];};
    const T & operator()(const index i0, const index i1) const { return _data[_idx(i0,i1)];};
    

    index ndim() const {return _ndim;}

    size_t size() const { return _size;}

    index shape(const index dim)  const {return _shape[dim];}

    template <typename VAL>
    void operator+=(const VAL & a) {xadd(*this,a);}

    template <typename VAL>
    void operator-=(const VAL& a) {xsub(*this,a);}


    template <typename VAL>
    void operator*=(const VAL& a) {xmul(*this,a);}


    template <typename VAL>
    void operator/=(const VAL & a) {xdiv(*this,a);}



    static void operate(std::function< void ( T& a, T&b)> f, TArray<T> & A, TArray<T> & B);

    static void operate(std::function< void ( T& a, T&b,T&c)> f, TArray<T> & A, TArray<T> & B,TArray<T> & C);


    T & operator[](const index i) { return _data[i];}

    const T & operator[](const index i) const  { return _data[i];};
        
    template <typename VAL>
    TArray<T>&  operator=(const VAL  &expr)  {return assign(*this,expr);}

    T*data() const { return _data;}


    void resize(size_t n);


    TArray(const TArray<T>& A)=delete;

    void savetxt(std::ostream &s) const;

  private:

    const index _ndim;

    size_t _size;
        
    index _shape[3]={0,0,0};


    void _check_bounds(index acc_dim, index acc_ndim, index acc_idx) const;


  protected:

    std::function<void(T*p)> _deleter=nullptr;

    std::shared_ptr<void>_datamanager =nullptr;

    T* _data=nullptr;

       
    void _assert_square() const;
        
    index _idx(index i0) const;

    index _idx(index i0,index i1)  const;

    index _idx(index i0,index i1,index i2)  const;

    TArray();

    void _nullify();

    void _setshape(index shape0);

    TArray(index n0);

    TArray(const std::initializer_list<T> &il );


    TArray(index n0, T*data, std::function<void(T*p)> deleter);

    TArray(index n0, T*data, std::shared_ptr<void> datamanager);

    TArray(index n0, index n1);

    TArray(const  std::initializer_list<std::initializer_list<T>> &il );


    TArray(index n0, index n1, T*data,std::function<void(T*p)> deleter);

    TArray(index n0, index n1, T*data,std::shared_ptr<void> datamanager);
        

    ~TArray();

    friend std::ostream & operator<< <T>(std::ostream & s, TArray<T> &A);


  };



  template<typename T> class TLinSolver
  {
  public:
    TLinSolver(){};
    virtual void solve( TArray<T> & sol,  const TArray<T> & rhs) const {};
    virtual void update(void){};
  };

  template<typename T> class TLinOperator
  {
  public:
    TLinOperator(){};
    virtual void apply( const TArray<T> & sol,   TArray<T> & rhs) const {};
  };
    
    
}


#include "tarray.ixx"
#endif