tensor_operation.hpp

 
#ifndef EXATN_NUMERICS_TENSOR_OPERATION_HPP_
#define EXATN_NUMERICS_TENSOR_OPERATION_HPP_
 
#include "tensor_basic.hpp"
#include "tensor.hpp"
 
#include <memory>
#include <string>
#include <vector>
#include <complex>
 
#include <iostream>
#include <fstream>
 
namespace exatn{
 
namespace runtime{
 // Tensor operation execution handle:
 using TensorOpExecHandle = std::size_t;
 // Forward for TensorNodeExecutor:
 class TensorNodeExecutor;
}
 
namespace numerics{
 
class TensorOperation{ //abstract
public:
 
 TensorOperation(TensorOpCode opcode,       //tensor operation code
                 unsigned int num_operands, //required number of tensor operands
                 unsigned int num_scalars); //required number of scalar operands
 
 TensorOperation(const TensorOperation &) = default;
 TensorOperation & operator=(const TensorOperation &) = default;
 TensorOperation(TensorOperation &&) noexcept = default;
 TensorOperation & operator=(TensorOperation &&) noexcept = default;
 virtual ~TensorOperation() = default;
 
 virtual bool isSet() const = 0;
 
 virtual int accept(runtime::TensorNodeExecutor & node_executor,
                    runtime::TensorOpExecHandle * exec_handle) = 0;
 
 virtual void printIt() const;
 virtual void printItFile(std::ofstream & output_file) const;
 
 TensorOpCode getOpcode() const;
 
 unsigned int getNumOperands() const;
 
 unsigned int getNumOperandsSet() const;
 
 TensorHashType getTensorOperandHash(unsigned int op_num) const;
 
 std::shared_ptr<Tensor> getTensorOperand(unsigned int op_num,
                                          bool * conjugated = nullptr) const;
 
 void setTensorOperand(std::shared_ptr<Tensor> tensor,
                       bool conjugated = false);
 
 unsigned int getNumScalars() const;
 
 unsigned int getNumScalarsSet() const;
 
 std::complex<double> getScalar(unsigned int scalar_num) const;
 
 void setScalar(unsigned int scalar_num,
                const std::complex<double> scalar);
 
 const std::string & getIndexPattern() const;
 
 void setIndexPattern(const std::string & pattern);
 
 void setId(std::size_t id);
 
 std::size_t getId() const;
 
protected:
 
 std::string pattern_; //symbolic index pattern
 std::vector<std::pair<std::shared_ptr<Tensor>,bool>> operands_; //tensor operands (non-owning pointers)
 std::vector<std::complex<double>> scalars_; //additional scalars (prefactors)
 unsigned int num_operands_; //number of required tensor operands
 unsigned int num_scalars_; //number of required scalar arguments
 TensorOpCode opcode_; //tensor operation code
 std::size_t id_; //tensor operation id (unique integer identifier)
};
 
using createTensorOpFn = std::unique_ptr<TensorOperation> (*)(void);
 
} //namespace numerics
 
} //namespace exatn
 
#endif //EXATN_NUMERICS_TENSOR_OPERATION_HPP_