term.h

Go to the documentation of this file.

#ifndef __TERM_H__
#define __TERM_H__

#include <map>
#include <set>
#include "../tensor/untyped_tensor.h"

namespace CTF {
  class Idx_Tensor;
}

namespace CTF_int {
  class Sum_Term;
  class Contract_Term;

  struct tensor_name_less {
    bool operator()(CTF::Idx_Tensor* A, CTF::Idx_Tensor* B);
  };


  class Term {
    public:
      char * scale;
      algstrct * sr;
     
      Term(algstrct const * sr);

      virtual ~Term();

      virtual Term * clone(std::map<tensor*, tensor*>* remap = NULL) const = 0;
      
      virtual void execute(CTF::Idx_Tensor output) const = 0;
      
      virtual double  estimate_time(CTF::Idx_Tensor output) const = 0;
      
      virtual CTF::Idx_Tensor estimate_time(double  & cost, std::vector<char> out_inds) const = 0;
      
      
      virtual CTF::Idx_Tensor execute(std::vector<char> out_inds) const = 0;

      virtual std::vector<char> get_uniq_inds() const = 0;
 
      virtual void get_inputs(std::set<CTF::Idx_Tensor*, tensor_name_less >* inputs_set) const = 0;

      void mult_scl(char const * mulscl);

      Contract_Term operator*(Term const & A) const;
      Contract_Term operator*(int64_t scl) const;
      Contract_Term operator*(double scl) const;
      
      Sum_Term operator+(Term const & A) const;
      Sum_Term operator+(double scl) const;
      Sum_Term operator+(int64_t scl) const;
      
      Sum_Term operator-(Term const & A) const;
      
      Sum_Term operator-(double scl) const;
      Sum_Term operator-(int64_t scl) const;
      
      Term & operator-();
      
      void operator=(CTF::Idx_Tensor const & B);
      void operator=(Term const & B);
      void operator+=(Term const & B);
      void operator-=(Term const & B);
      void operator*=(Term const & B);

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

      void operator-=(double scl);
      void operator*=(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);
      virtual CTF::World * where_am_i() const = 0;

      operator float() const;

      operator double() const;
 
      operator int64_t() const;
 
      operator int() const;
  };

  class Sum_Term : public Term {
    public:
      std::vector< Term* > operands;

      Sum_Term(Term * B, Term * A);

      // destructor frees operands
      ~Sum_Term();
    
      // copy constructor
      Sum_Term(Sum_Term const & other,
               std::map<tensor*, tensor*>* remap = NULL);

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

      //Sum_Term(CTF::Idx_Tensor const & tsr);

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

      Sum_Term operator+(Term const & A) const;
      
      Sum_Term operator-(Term const & A) const;
 
//      Sum_Term operator-() const;


      CTF::World * where_am_i() const;
  };

  class Contract_Term : public Term {
    public:
      std::vector< Term* > operands;

 
      Contract_Term(Term * B, Term * A);


      // \brief destructor frees operands
      ~Contract_Term();
    
      // \brief copy constructor
      Contract_Term(Contract_Term const & other,
          std::map<tensor*, tensor*>* remap = NULL);

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

      void execute(CTF::Idx_Tensor output) const;

      std::vector<char> get_uniq_inds() const;
 
      void get_inputs(std::set<CTF::Idx_Tensor*, tensor_name_less >* inputs_set) const;

      CTF::Idx_Tensor execute(std::vector<char> out_inds) const;
      
      double  estimate_time(CTF::Idx_Tensor output) const;
      
      CTF::Idx_Tensor estimate_time(double  & cost, std::vector<char> out_inds) const;
      
      
      Contract_Term operator*(Term const & A) const;
 
//      Contract_Term operator-() const;

      CTF::World * where_am_i() const;
  };


  //FIXME: what if noncommutative?
  inline CTF_int::Contract_Term operator*(double const & d, CTF_int::Term const & tsr){
    return (tsr*d);
  }

  //FIXME: what if noncommutative?
  inline CTF_int::Contract_Term operator*(int64_t const & i, CTF_int::Term const & tsr){
    return (tsr*i);
  }

  void operator-=(double & d, CTF_int::Term const & tsr);

  void operator+=(double & d, CTF_int::Term const & tsr);

  void operator-=(int64_t & d, CTF_int::Term const & tsr);

  void operator+=(int64_t & d, CTF_int::Term const & tsr);


}

#endif