Net is a library for dynamic Networks of EveryThing

# net::tensor

# Classes

Name
struct net::tensor::absorb
struct net::tensor::auto_qr
struct net::tensor::contract
struct net::tensor::default_dec
struct net::tensor::qr
struct net::tensor::svd
struct net::tensor::svd2

# Types

Name
template <typename T ,typename SiteKey =std::string,typename EdgeKey =stdEdgeKey>
using network< Tensor< T, EdgeKey >, Tensor< T, EdgeKey >, SiteKey, EdgeKey, default_traits< Tensor< T, EdgeKey >, Tensor< T, EdgeKey >, SiteKey, EdgeKey > >		 TensorNetworkEnv
template <typename T ,typename SiteKey =std::string,typename EdgeKey =stdEdgeKey>
using network< Tensor< T, EdgeKey >, std::monostate, SiteKey, EdgeKey, default_traits< Tensor< T, EdgeKey >, std::monostate, SiteKey, EdgeKey > >		 TensorNetworkNoEnv
template <typename T ,typename EdgeKey =stdEdgeKey>
using TAT::Tensor< T, TAT::NoSymmetry, EdgeKey >		 Tensor

# Functions

Name
template <typename NetType >
NetType::NodeValType		 init_node_rand(const typename NetType::NodeType & this_node, const unsigned int D, const double min, const double max, std::default_random_engine & R)
template <typename NetType >
NetType::NodeValType		 init_node_rand_phy(const typename NetType::NodeType & this_node, const unsigned int D, const unsigned int dphy, std::default_random_engine & R)
template <typename NetType >
NetType::EdgeValType		 init_edge_one(const typename NetType::NodeType & this_node, const typename NetType::EdgeKeyType & edge1, const unsigned int D)
template <typename NetType >
NetType::EdgeValType		 init_edge_null(const typename NetType::NodeType & this_node, const typename NetType::EdgeKeyType & edge1)
template <typename T ,typename EdgeKey =stdEdgeKey>
std::monostate		 zero_map(const Tensor< T, EdgeKey > & ten)
std::string conjugate_string(const std::string & s)
std::monostate conjugate_mono(const std::monostate & m)
template <typename T >
Tensor< T >		 conjugate_tensor(const Tensor< T > & t)
template <typename T >
TensorNetworkEnv< T >		 conjugate_tnenv(const TensorNetworkEnv< T > & t)
template <typename T >
TensorNetworkNoEnv< T >		 conjugate_tnnoenv(const TensorNetworkNoEnv< T > & t)
template <typename T >
TensorNetworkEnv< T >		 double_tnenv(const TensorNetworkEnv< T > & t)
template <typename T >
TensorNetworkNoEnv< T >		 double_tnnoenv(const TensorNetworkNoEnv< T > & t)
template <template< typename > typename TreeVal,typename NetType ,typename Engine >
std::shared_ptr< net::tree< TreeVal< typename NetType::NodeKeySetType > > >		 get_contract_tree(const NetType & lat, Engine & eg, const std::string & method)
template <typename Network >
Network::NodeValType		 contract_tn(const Network & n, Engine & eg, const std::string & method)
template <typename TnType >
int		 get_dim(TnType ten, int s)
template <typename TnType >
int		 get_size(TnType ten)
template <typename TnType >
int		 get_rank(TnType ten)
template <typename T >
std::set< std::string >		 inds_start_with(const TAT::Tensor< T > & ten, const std::string & head)
template <typename TnType ,typename EdgeKey >
int		 get_dim(TnType ten, EdgeKey s)
template <typename TnType >
void		 diminfo(TnType ten, std::ostream & os)
template <typename T ,typename EdgeKey =stdEdgeKey>
Tensor< T, EdgeKey >		 get_diag(const Tensor< T, EdgeKey > & ten, std::vector< std::pair< EdgeKey, EdgeKey > > names)
得到tensor的对角元

# Attributes

Name
std::function< std::string(const std::string &)> conjugate_string_fun
std::function< std::monostate(const std::monostate &)> conjugate_mono_fun
std::function< Tensor< T >(const Tensor< T > &)> conjugate_tensor_fun

# Types Documentation

# using TensorNetworkEnv

template <typename T ,
typename SiteKey  =std::string,
typename EdgeKey  =stdEdgeKey>
using net::tensor::TensorNetworkEnv = typedef network< Tensor<T, EdgeKey>, Tensor<T, EdgeKey>, SiteKey, EdgeKey, default_traits<Tensor<T, EdgeKey>, Tensor<T, EdgeKey>, SiteKey, EdgeKey> >;

# using TensorNetworkNoEnv

template <typename T ,
typename SiteKey  =std::string,
typename EdgeKey  =stdEdgeKey>
using net::tensor::TensorNetworkNoEnv = typedef network<Tensor<T, EdgeKey>, std::monostate, SiteKey, EdgeKey, default_traits<Tensor<T, EdgeKey>, std::monostate, SiteKey, EdgeKey> >;

# using Tensor

template <typename T ,
typename EdgeKey  =stdEdgeKey>
using net::tensor::Tensor = typedef TAT::Tensor<T, TAT::NoSymmetry, EdgeKey>;

# Functions Documentation

# function init_node_rand

template <typename NetType >
NetType::NodeValType init_node_rand(
    const typename NetType::NodeType & this_node,
    const unsigned int D,
    const double min,
    const double max,
    std::default_random_engine & R
)

# function init_node_rand_phy

template <typename NetType >
NetType::NodeValType init_node_rand_phy(
    const typename NetType::NodeType & this_node,
    const unsigned int D,
    const unsigned int dphy,
    std::default_random_engine & R
)

# function init_edge_one

template <typename NetType >
NetType::EdgeValType init_edge_one(
    const typename NetType::NodeType & this_node,
    const typename NetType::EdgeKeyType & edge1,
    const unsigned int D
)

# function init_edge_null

template <typename NetType >
NetType::EdgeValType init_edge_null(
    const typename NetType::NodeType & this_node,
    const typename NetType::EdgeKeyType & edge1
)

# function zero_map

template <typename T ,
typename EdgeKey  =stdEdgeKey>
std::monostate zero_map(
    const Tensor< T, EdgeKey > & ten
)

# function conjugate_string

inline std::string conjugate_string(
    const std::string & s
)

# function conjugate_mono

inline std::monostate conjugate_mono(
    const std::monostate & m
)

# function conjugate_tensor

template <typename T >
Tensor< T > conjugate_tensor(
    const Tensor< T > & t
)

# function conjugate_tnenv

template <typename T >
TensorNetworkEnv< T > conjugate_tnenv(
    const TensorNetworkEnv< T > & t
)

# function conjugate_tnnoenv

template <typename T >
TensorNetworkNoEnv< T > conjugate_tnnoenv(
    const TensorNetworkNoEnv< T > & t
)

# function double_tnenv

template <typename T >
TensorNetworkEnv< T > double_tnenv(
    const TensorNetworkEnv< T > & t
)

# function double_tnnoenv

template <typename T >
TensorNetworkNoEnv< T > double_tnnoenv(
    const TensorNetworkNoEnv< T > & t
)

# function get_contract_tree

template <template< typename > typename TreeVal,
typename NetType ,
typename Engine >
std::shared_ptr< net::tree< TreeVal< typename NetType::NodeKeySetType > > > get_contract_tree(
    const NetType & lat,
    Engine & eg,
    const std::string & method
)

# function contract_tn

template <typename Network >
Network::NodeValType contract_tn(
    const Network & n,
    Engine & eg,
    const std::string & method
)

# function get_dim

template <typename TnType >
int get_dim(
    TnType ten,
    int s
)

# function get_size

template <typename TnType >
int get_size(
    TnType ten
)

# function get_rank

template <typename TnType >
int get_rank(
    TnType ten
)

# function inds_start_with

template <typename T >
std::set< std::string > inds_start_with(
    const TAT::Tensor< T > & ten,
    const std::string & head
)

# function get_dim

template <typename TnType ,
typename EdgeKey >
int get_dim(
    TnType ten,
    EdgeKey s
)

# function diminfo

template <typename TnType >
void diminfo(
    TnType ten,
    std::ostream & os
)

# function get_diag

template <typename T ,
typename EdgeKey  =stdEdgeKey>
Tensor< T, EdgeKey > get_diag(
    const Tensor< T, EdgeKey > & ten,
    std::vector< std::pair< EdgeKey, EdgeKey > > names
)

得到tensor的对角元

# Attributes Documentation

# variable conjugate_string_fun

std::function< std::string(const std::string &)> conjugate_string_fun = [conjugate_string](/Namespaces/namespacenet_1_1tensor.md#function-conjugate_string);

# variable conjugate_mono_fun

std::function< std::monostate(const std::monostate &)> conjugate_mono_fun = [conjugate_mono](/Namespaces/namespacenet_1_1tensor.md#function-conjugate_mono);

# variable conjugate_tensor_fun

std::function< Tensor< T >(const Tensor< T > &)> conjugate_tensor_fun = [conjugate_tensor](/Namespaces/namespacenet_1_1tensor.md#function-conjugate_tensor)<T>;

Updated on 15 June 2022 at 16:04:19 CST