tensor.hpp

 
#ifndef EXATN_NUMERICS_TENSOR_HPP_
#define EXATN_NUMERICS_TENSOR_HPP_
 
#include "tensor_basic.hpp"
#include "tensor_shape.hpp"
#include "tensor_signature.hpp"
#include "tensor_leg.hpp"
 
#include <assert.h>
 
#include <iostream>
#include <fstream>
#include <type_traits>
#include <string>
#include <initializer_list>
#include <vector>
#include <list>
#include <memory>
 
namespace exatn{
 
namespace numerics{
 
using TensorHashType = std::size_t;
 
class Tensor{
public:
 
 Tensor(const std::string & name,           //tensor name
        const TensorShape & shape,          //tensor shape
        const TensorSignature & signature); //tensor signature
 Tensor(const std::string & name,           //tensor name
        const TensorShape & shape);         //tensor shape
 template<typename T>
 Tensor(const std::string & name,                                        //tensor name
        std::initializer_list<T> extents,                                //tensor dimension extents
        std::initializer_list<std::pair<SpaceId,SubspaceId>> subspaces); //tensor dimension defining subspaces
 template<typename T>
 Tensor(const std::string & name,                                      //tensor name
        const std::vector<T> & extents,                                //tensor dimension extents
        const std::vector<std::pair<SpaceId,SubspaceId>> & subspaces); //tensor dimension defining subspaces
 template<typename T>
 Tensor(const std::string & name,          //tensor name
        std::initializer_list<T> extents); //tensor dimension extents
 template<typename T>
 Tensor(const std::string & name,        //tensor name
        const std::vector<T> & extents); //tensor dimension extents
 Tensor(const std::string & name);       //tensor name
 Tensor(const std::string & name,                    //tensor name
        const Tensor & left_tensor,                  //left tensor
        const Tensor & right_tensor,                 //right tensor
        const std::vector<TensorLeg> & contraction); //tensor contraction pattern
 
 Tensor(const Tensor & tensor) = default;
 Tensor & operator=(const Tensor & tensor) = default;
 Tensor(Tensor && tensor) noexcept = default;
 Tensor & operator=(Tensor && tensor) noexcept = default;
 virtual ~Tensor() = default;
 
 void printIt() const;
 void printItFile(std::ofstream & output_file) const;
 
 const std::string & getName() const;
 unsigned int getRank() const;
 const TensorShape & getShape() const;
 const TensorSignature & getSignature() const;
 
 DimExtent getDimExtent(unsigned int dim_id) const;
 const std::vector<DimExtent> & getDimExtents() const;
 
 SpaceId getDimSpaceId(unsigned int dim_id) const;
 SubspaceId getDimSubspaceId(unsigned int dim_id) const;
 std::pair<SpaceId,SubspaceId> getDimSpaceAttr(unsigned int dim_id) const;
 
 bool isCongruentTo(const Tensor & another) const;
 
 void deleteDimension(unsigned int dim_id);
 
 void appendDimension(std::pair<SpaceId,SubspaceId> subspace,
                      DimExtent dim_extent);
 void appendDimension(DimExtent dim_extent);
 
 std::shared_ptr<Tensor> createSubtensor(const std::string & name,           //in: subtensor name
                                         const std::vector<int> & mode_mask, //in: mode masks
                                         int mask_val);                      //in: chosen mask value
 
 void setElementType(TensorElementType element_type);
 
 TensorElementType getElementType() const;
 
 void registerIsometry(const std::vector<unsigned int> & isometry);
 
 const std::list<std::vector<unsigned int>> & retrieveIsometries() const;
 
 TensorHashType getTensorHash() const;
 
private:
 
 std::string name_;               //tensor name
 TensorShape shape_;              //tensor shape
 TensorSignature signature_;      //tensor signature
 TensorElementType element_type_; //tensor element type (optional)
 std::list<std::vector<unsigned int>> isometries_; //available isometries (optional)
};
 
 
//TEMPLATES:
template<typename T>
Tensor::Tensor(const std::string & name,
               std::initializer_list<T> extents,
               std::initializer_list<std::pair<SpaceId,SubspaceId>> subspaces):
name_(name), shape_(extents), signature_(subspaces), element_type_(TensorElementType::VOID)
{
 //DEBUG:
 if(signature_.getRank() != shape_.getRank()) std::cout << "ERROR(Tensor::Tensor): Signature/Shape size mismatch!" << std::endl;
 assert(signature_.getRank() == shape_.getRank());
}
 
template<typename T>
Tensor::Tensor(const std::string & name,
               const std::vector<T> & extents,
               const std::vector<std::pair<SpaceId,SubspaceId>> & subspaces):
name_(name), shape_(extents), signature_(subspaces), element_type_(TensorElementType::VOID)
{
 //DEBUG:
 if(signature_.getRank() != shape_.getRank()) std::cout << "ERROR(Tensor::Tensor): Signature/Shape size mismatch!" << std::endl;
 assert(signature_.getRank() == shape_.getRank());
}
 
template<typename T>
Tensor::Tensor(const std::string & name,
               std::initializer_list<T> extents):
name_(name), shape_(extents), signature_(static_cast<unsigned int>(extents.size())), element_type_(TensorElementType::VOID)
{
}
 
template<typename T>
Tensor::Tensor(const std::string & name,
               const std::vector<T> & extents):
name_(name), shape_(extents), signature_(static_cast<unsigned int>(extents.size())), element_type_(TensorElementType::VOID)
{
}
 
} //namespace numerics
 
template<typename... Args>
inline std::shared_ptr<numerics::Tensor> makeSharedTensor(Args&&... args)
{
 return std::make_shared<numerics::Tensor>(args...);
}
 
} //namespace exatn
 
#endif //EXATN_NUMERICS_TENSOR_HPP_