idx_tensor.h

Go to the documentation of this file.

#ifndef __EXPRESSION_H__
#define __EXPRESSION_H__

#include "term.h"
#include "functions.h"

namespace CTF {
  class Idx_Tensor : public CTF_int::Term {
    public:
      CTF_int::tensor * parent;
      char * idx_map;
      int is_intm;

    
      // derived clone calls copy constructor
      CTF_int::Term * clone(std::map< CTF_int::tensor*, CTF_int::tensor* >* remap = NULL) const;

      Idx_Tensor(CTF_int::tensor * parent_,
                 const char *      idx_map_,
                 int               copy=0);
      
      Idx_Tensor(CTF::Idx_Tensor const &                       other,
                 int                                           copy=0,
                 std::map<CTF_int::tensor*, CTF_int::tensor*>* remap=NULL);

      Idx_Tensor(CTF_int::algstrct const * sr);
      Idx_Tensor(CTF_int::algstrct const * sr, double scl);
      Idx_Tensor(CTF_int::algstrct const * sr, int64_t scl);
      ~Idx_Tensor();
      

      Idx_Tensor execute(std::vector<char> out_inds) const;
      
      void execute(Idx_Tensor output) const;
      
      double estimate_time(Idx_Tensor output) const;
      
      Idx_Tensor estimate_time(double  & cost, std::vector<char> out_inds) const;
      
      std::vector<char> get_uniq_inds() const;
 
      void get_inputs(std::set<Idx_Tensor*, CTF_int::tensor_name_less >* inputs_set) const;

      void operator=(CTF_int::Term const & B);
      void operator=(Idx_Tensor const & B);

      //same as in parent (Term) but not inherited in C++
      void operator=(double scl);
      void operator+=(double scl);
      void operator-=(double scl);
      void operator*=(double scl);
      void multeq(double scl);
      void operator=(int64_t scl);
      void operator+=(int64_t scl);
      void operator-=(int64_t scl);
      void operator*=(int64_t scl);
      void operator=(int scl);
      void operator+=(int scl);
      void operator-=(int scl);
      void operator*=(int scl);

      void operator+=(CTF_int::Term const & B);

      void operator-=(CTF_int::Term const & B);

//      Idx_Tensor operator-() const;
 
      
      void operator*=(CTF_int::Term const & B);

      //void operator/(IdxTensor& tsr);
      
      //void run(Idx_Tensor* output, dtype  beta);

      /*operator CTF_int::Term* (){
        Idx_Tensor * tsr = new Idx_Tensor(*this);
        return tsr;
      }*/


      World * where_am_i() const;
  };

  template<typename dtype>
  class Typ_Idx_Tensor;

  
  template<typename dtype_A, typename dtype_B>
  class Univar_Transform;
  
  template<typename dtype_A, typename dtype_B, typename dtype_C>
  class Typ_Contract_Term;
  
  template<typename dtype_A, typename dtype_B>
  class Typ_Sum_Term : public CTF_int::Sum_Term {
    public:

      Typ_Sum_Term(Typ_Idx_Tensor<dtype_A> * A, Typ_Idx_Tensor<dtype_B> * B) : CTF_int::Sum_Term(A,B) {}

      void operator()(std::function<void(dtype_A, dtype_B&)> f){
        (Transform<dtype_A,dtype_B>(f))(*operands[0],*operands[1]);
      }

      void operator,(std::function<void(dtype_A, dtype_B&)> f){
        (Transform<dtype_A,dtype_B>(f))(*operands[0],*operands[1]);
      }

      void operator()(std::function<dtype_B(dtype_A)> f){
        ((Function<dtype_A,dtype_B>(f))(*operands[0])).execute(operands[1]->execute(this->get_uniq_inds()));
      }

      void operator,(std::function<dtype_B(dtype_A)> f){
        ((Function<dtype_A,dtype_B>(f))(*operands[0])).execute(operands[1]->execute(this->get_uniq_inds()));
      }
 
      
      template<typename dtype_C>
      Typ_Contract_Term<dtype_A,dtype_B,dtype_C> operator&(Typ_Idx_Tensor<dtype_C> C){
        return Typ_Contract_Term<dtype_A,dtype_B,dtype_C>(&C, *this);
      }
  };
  
  template<typename dtype_A, typename dtype_B, typename dtype_C>
  class Typ_Contract_Term : public CTF_int::Contract_Term {
    public:
      Typ_Idx_Tensor<dtype_C> * C;
      Typ_Contract_Term(Typ_Idx_Tensor<dtype_C> * C_, 
                        Typ_Sum_Term<dtype_A,dtype_B> S) 
          : Contract_Term(S.operands[0]->clone(), 
                          S.operands[1]->clone()) {
        C = C_;
      }
      
      void operator,(std::function<dtype_C(dtype_A, dtype_B)> f){
        ((Function<dtype_A,dtype_B,dtype_C>(f))(*operands[1],*operands[0])).execute(*C);
      }
      
      void operator,(std::function<void(dtype_A, dtype_B, dtype_C&)> f){
        ((Transform<dtype_A,dtype_B,dtype_C>(f)))(*operands[1],*operands[0],*C);
      }
        
  };

  template<typename dtype>
  class Typ_AIdx_Tensor;

  template<typename dtype>
  class Typ_Idx_Tensor : public Idx_Tensor {
    public:
      ~Typ_Idx_Tensor(){}

      Typ_Idx_Tensor(CTF_int::tensor * parent_,
                     const char *      idx_map_,
                     int               copy=0) : Idx_Tensor(parent_, idx_map_, copy) {}
      
      Typ_Idx_Tensor(Typ_Idx_Tensor const &                            B,
                     int                                           copy=0,
                     std::map<CTF_int::tensor*, CTF_int::tensor*>* remap=NULL) : Idx_Tensor(B, copy, remap) {}


      Typ_Idx_Tensor<dtype> * tclone() const { return new Typ_Idx_Tensor<dtype>(*this); }

      CTF_int::Term * clone(std::map< CTF_int::tensor*, CTF_int::tensor* >* remap = NULL) const { return new Typ_Idx_Tensor<dtype>(*this, 0, remap); }

      void operator=(CTF_int::Term const & B){ Idx_Tensor::operator=(B); }
      void operator=(Idx_Tensor const & B){ Idx_Tensor::operator=(B); }
      void operator=(double scl){ Idx_Tensor::operator=(scl); }
      void operator=(int64_t scl){ Idx_Tensor::operator=(scl); }
      void operator=(int scl){ Idx_Tensor::operator=(scl); }



      template <typename dtype_B>
      Typ_Sum_Term<dtype, dtype_B> operator&(Typ_Idx_Tensor<dtype_B> B){
        return Typ_Sum_Term<dtype, dtype_B>(this->tclone(), B.tclone());
      }
 
      template <typename dtype_A, typename dtype_B>
      Typ_Contract_Term<dtype_A, dtype_B, dtype> operator+=(Typ_Sum_Term<dtype_A,dtype_B> t){
        return Typ_Contract_Term<dtype_A,dtype_B,dtype>(this->tclone(), t);
      }
     /* 
      template <typename dtype_A, typename dtype_B>
      Typ_Contract_Term<dtype_A, dtype_B, dtype> operator&=(Typ_Sum_Term<dtype_A,dtype_B> t){
        sr->safecopy(scale,sr->addid());
        return Typ_Contract_Term<dtype_A,dtype_B,dtype>(this->clone(), t);
      }*/
      
      template <typename dtype_A, typename dtype_B>
      Typ_Contract_Term<dtype_A, dtype_B, dtype> operator=(Typ_Sum_Term<dtype_A,dtype_B> t){
        sr->safecopy(scale,sr->addid());
        return Typ_Contract_Term<dtype_A,dtype_B,dtype>(this, t);
      }

      Typ_AIdx_Tensor<dtype> operator~(){
        return Typ_AIdx_Tensor<dtype>(*this);
      }
 
      
      template <typename dtype_A>
      Typ_Sum_Term<dtype_A, dtype> operator=(Typ_AIdx_Tensor<dtype_A> t){
        sr->safecopy(scale,sr->addid());
        return Typ_Sum_Term<dtype_A,dtype>(t.tclone(), this->tclone());
      }
      
      template <typename dtype_A>
      Typ_Sum_Term<dtype_A, dtype> operator+=(Typ_AIdx_Tensor<dtype_A> t){
        return Typ_Sum_Term<dtype_A,dtype>(t.tclone(), this->tclone());
      }

      void operator+=(CTF_int::Term const & B){ Idx_Tensor::operator+=(B); }
      void operator+=(Idx_Tensor const & B){ Idx_Tensor::operator+=(B); }
      void operator+=(double scl){ Idx_Tensor::operator+=(scl); }
      void operator+=(int64_t scl){ Idx_Tensor::operator+=(scl); }
      void operator+=(int scl){ Idx_Tensor::operator+=(scl); }


      void operator,(std::function<void(dtype&)> f){
        ((Transform<dtype>(f)))(*this);
      }
      
      void operator()(std::function<void(dtype&)> f){
        ((Transform<dtype>(f)))(*this);
      }
        
  };

  template<typename dtype>
  class Typ_AIdx_Tensor : public Typ_Idx_Tensor<dtype> {
    public:
      Typ_AIdx_Tensor(Typ_Idx_Tensor<dtype> const & A) : Typ_Idx_Tensor<dtype>(A) {};
  };
}


//include here because requires above defs
#include "../tensor/untyped_tensor_tmpl.h"
#endif