BlackCat_Tensors
A GPU-supported autograd and linear algebra library, designed for neural network construction
Classes | Public Types | Public Member Functions | Static Public Attributes | Friends | List of all members
bc::tensors::Expression_Base< ExpressionTemplate > Class Template Reference

#include <cmath.h>

Inheritance diagram for bc::tensors::Expression_Base< ExpressionTemplate >:
Inheritance graph
[legend]
Collaboration diagram for bc::tensors::Expression_Base< ExpressionTemplate >:
Collaboration graph
[legend]

Classes

struct  cw_iterator_type
 
struct  cw_reverse_iterator_type
 

Public Types

using value_type = typename ExpressionTemplate::value_type
 
using system_tag = typename ExpressionTemplate::system_tag
 

Public Member Functions

 Expression_Base ()
 
 Expression_Base (const ExpressionTemplate &et)
 
 Expression_Base (ExpressionTemplate &&et)
 
template<class... params>
auto cw_iter (params... ps) const
 
template<class... params>
auto cw_iter (params... ps)
 
template<class... params>
auto cw_const_iter (params... ps) const
 
template<class... params>
auto cw_reverse_iter (params... ps) const
 
template<class... params>
auto cw_reverse_iter (params... ps)
 
template<class... params>
auto cw_reverse_const_iter (params... ps) const
 
auto cw_begin () const
 
auto cw_begin ()
 
auto cw_cbegin () const
 
auto cw_rbegin () const
 
auto cw_rbegin ()
 
auto cw_crbegin () const
 
auto cw_end () const
 
auto cw_end ()
 
auto cw_cend () const
 
auto cw_rend () const
 
auto cw_rend ()
 
auto cw_crend () const
 
template<class Xpr >
auto operator+ (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator+ (const ScalarType &param) const
 
template<class Xpr >
auto operator- (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator- (const ScalarType &param) const
 
template<class Xpr >
auto operator% (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator% (const ScalarType &param) const
 
template<class Xpr >
auto operator/ (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator/ (const ScalarType &param) const
 
template<class Xpr >
auto operator== (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator== (const ScalarType &param) const
 
template<class Xpr >
auto operator> (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator> (const ScalarType &param) const
 
template<class Xpr >
auto operator< (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator< (const ScalarType &param) const
 
template<class Xpr >
auto operator>= (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator>= (const ScalarType &param) const
 
template<class Xpr >
auto operator<= (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator<= (const ScalarType &param) const
 
template<class Xpr >
auto operator&& (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator&& (const ScalarType &param) const
 
template<class Xpr >
auto operator|| (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator|| (const ScalarType &param) const
 
template<class Xpr >
auto approx_equal (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto approx_equal (const ScalarType &param) const
 
template<class Xpr >
auto max_value (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto max_value (const ScalarType &param) const
 
template<class Xpr >
auto min_value (const Expression_Base< Xpr > &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto min_value (const ScalarType &param) const
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator* (const ScalarType &param) const
 
template<class Xpr >
auto operator* (const Expression_Base< Xpr > &param) const
 
const auto transpose () const
 
auto transpose ()
 
const auto t () const
 
auto t ()
 
auto operator- () const
 
template<class functor >
auto un_expr (functor f) const
 
template<class Functor , class Xpr , class = std::enable_if_t< exprs::expression_traits<Xpr>::is_expression_template::value>>
auto bi_expr (Functor func, const Xpr &rv) const
 
template<class Xpr >
void assert_valid (const Expression_Base< Xpr > &tensor) const
 
template<class Xpr >
bool valid_slice (const Expression_Base< Xpr > &tensor) const
 

Static Public Attributes

static constexpr int tensor_dim = expression_type::tensor_dim
 
static constexpr int tensor_iterator_dim = expression_type::tensor_iterator_dim
 

Friends

template<class >
class Tensor_Base
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator+ (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator- (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator% (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator/ (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator== (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator> (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator< (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator>= (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator<= (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator&& (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator|| (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto approx_equal (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto max_value (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto min_value (const ScalarType &param, const Expression_Base &tensor)
 
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator* (const ScalarType &param, const Expression_Base &tensor)
 

Member Typedef Documentation

◆ system_tag

template<class ExpressionTemplate>
using bc::tensors::Expression_Base< ExpressionTemplate >::system_tag = typename ExpressionTemplate::system_tag

◆ value_type

template<class ExpressionTemplate>
using bc::tensors::Expression_Base< ExpressionTemplate >::value_type = typename ExpressionTemplate::value_type

Constructor & Destructor Documentation

◆ Expression_Base() [1/3]

template<class ExpressionTemplate>
bc::tensors::Expression_Base< ExpressionTemplate >::Expression_Base ( )
inline

◆ Expression_Base() [2/3]

template<class ExpressionTemplate>
bc::tensors::Expression_Base< ExpressionTemplate >::Expression_Base ( const ExpressionTemplate &  et)
inline

◆ Expression_Base() [3/3]

template<class ExpressionTemplate>
bc::tensors::Expression_Base< ExpressionTemplate >::Expression_Base ( ExpressionTemplate &&  et)
inline

Member Function Documentation

◆ approx_equal() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::approx_equal ( const Expression_Base< Xpr > &  param) const
inline

◆ approx_equal() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::approx_equal ( const ScalarType &  param) const
inline

◆ assert_valid()

template<class ExpressionTemplate>
template<class Xpr >
void bc::tensors::Expression_Base< ExpressionTemplate >::assert_valid ( const Expression_Base< Xpr > &  tensor) const
inline

◆ bi_expr()

template<class ExpressionTemplate>
template<class Functor , class Xpr , class = std::enable_if_t< exprs::expression_traits<Xpr>::is_expression_template::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::bi_expr ( Functor  func,
const Xpr &  rv 
) const
inline

◆ cw_begin() [1/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_begin ( ) const
inline

◆ cw_begin() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_begin ( )
inline

◆ cw_cbegin()

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_cbegin ( ) const
inline

◆ cw_cend()

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_cend ( ) const
inline

◆ cw_const_iter()

template<class ExpressionTemplate>
template<class... params>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_const_iter ( params...  ps) const
inline

◆ cw_crbegin()

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_crbegin ( ) const
inline

◆ cw_crend()

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_crend ( ) const
inline

◆ cw_end() [1/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_end ( ) const
inline

◆ cw_end() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_end ( )
inline

◆ cw_iter() [1/2]

template<class ExpressionTemplate>
template<class... params>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_iter ( params...  ps)
inline

◆ cw_iter() [2/2]

template<class ExpressionTemplate>
template<class... params>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_iter ( params...  ps) const
inline

◆ cw_rbegin() [1/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_rbegin ( ) const
inline

◆ cw_rbegin() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_rbegin ( )
inline

◆ cw_rend() [1/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_rend ( ) const
inline

◆ cw_rend() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_rend ( )
inline

◆ cw_reverse_const_iter()

template<class ExpressionTemplate>
template<class... params>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_reverse_const_iter ( params...  ps) const
inline

◆ cw_reverse_iter() [1/2]

template<class ExpressionTemplate>
template<class... params>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_reverse_iter ( params...  ps) const
inline

◆ cw_reverse_iter() [2/2]

template<class ExpressionTemplate>
template<class... params>
auto bc::tensors::Expression_Base< ExpressionTemplate >::cw_reverse_iter ( params...  ps)
inline

◆ max_value() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::max_value ( const Expression_Base< Xpr > &  param) const
inline

◆ max_value() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::max_value ( const ScalarType &  param) const
inline

◆ min_value() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::min_value ( const Expression_Base< Xpr > &  param) const
inline

◆ min_value() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::min_value ( const ScalarType &  param) const
inline

◆ operator%() [1/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator% ( const ScalarType &  param) const
inline

◆ operator%() [2/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator% ( const Expression_Base< Xpr > &  param) const
inline

◆ operator&&() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator && ( const Expression_Base< Xpr > &  param) const
inline

◆ operator&&() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator && ( const ScalarType &  param) const
inline

◆ operator*() [1/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator* ( const ScalarType &  param) const
inline

◆ operator*() [2/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator* ( const Expression_Base< Xpr > &  param) const
inline

◆ operator+() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator+ ( const Expression_Base< Xpr > &  param) const
inline

◆ operator+() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator+ ( const ScalarType &  param) const
inline

◆ operator-() [1/3]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator- ( const Expression_Base< Xpr > &  param) const
inline

◆ operator-() [2/3]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator- ( const ScalarType &  param) const
inline

◆ operator-() [3/3]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator- ( ) const
inline

◆ operator/() [1/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator/ ( const ScalarType &  param) const
inline

◆ operator/() [2/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator/ ( const Expression_Base< Xpr > &  param) const
inline

◆ operator<() [1/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator< ( const ScalarType &  param) const
inline

◆ operator<() [2/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator< ( const Expression_Base< Xpr > &  param) const
inline

◆ operator<=() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator<= ( const Expression_Base< Xpr > &  param) const
inline

◆ operator<=() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator<= ( const ScalarType &  param) const
inline

◆ operator==() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator== ( const Expression_Base< Xpr > &  param) const
inline

◆ operator==() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator== ( const ScalarType &  param) const
inline

◆ operator>() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator> ( const Expression_Base< Xpr > &  param) const
inline

◆ operator>() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator> ( const ScalarType &  param) const
inline

◆ operator>=() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator>= ( const Expression_Base< Xpr > &  param) const
inline

◆ operator>=() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator>= ( const ScalarType &  param) const
inline

◆ operator||() [1/2]

template<class ExpressionTemplate>
template<class Xpr >
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator|| ( const Expression_Base< Xpr > &  param) const
inline

◆ operator||() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto bc::tensors::Expression_Base< ExpressionTemplate >::operator|| ( const ScalarType &  param) const
inline

◆ t() [1/2]

template<class ExpressionTemplate>
const auto bc::tensors::Expression_Base< ExpressionTemplate >::t ( ) const
inline

◆ t() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::t ( )
inline

◆ transpose() [1/2]

template<class ExpressionTemplate>
const auto bc::tensors::Expression_Base< ExpressionTemplate >::transpose ( ) const
inline

◆ transpose() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Expression_Base< ExpressionTemplate >::transpose ( )
inline

◆ un_expr()

template<class ExpressionTemplate>
template<class functor >
auto bc::tensors::Expression_Base< ExpressionTemplate >::un_expr ( functor  f) const
inline

◆ valid_slice()

template<class ExpressionTemplate>
template<class Xpr >
bool bc::tensors::Expression_Base< ExpressionTemplate >::valid_slice ( const Expression_Base< Xpr > &  tensor) const
inline

Friends And Related Function Documentation

◆ approx_equal

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto approx_equal ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ max_value

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto max_value ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ min_value

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto min_value ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator%

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator% ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator&&

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator && ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator*

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator* ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator+

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator+ ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator-

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator- ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator/

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator/ ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator<

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator< ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator<=

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator<= ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator==

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator== ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator>

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator> ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator>=

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator>= ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ operator||

template<class ExpressionTemplate>
template<class ScalarType , class = std::enable_if_t< std::is_convertible<ScalarType, value_type>::value>>
auto operator|| ( const ScalarType &  param,
const Expression_Base< ExpressionTemplate > &  tensor 
)
friend

◆ Tensor_Base

template<class ExpressionTemplate>
template<class >
friend class Tensor_Base
friend

Member Data Documentation

◆ tensor_dim

template<class ExpressionTemplate>
constexpr int bc::tensors::Expression_Base< ExpressionTemplate >::tensor_dim = expression_type::tensor_dim
static

◆ tensor_iterator_dim

template<class ExpressionTemplate>
constexpr int bc::tensors::Expression_Base< ExpressionTemplate >::tensor_iterator_dim = expression_type::tensor_iterator_dim
static
The documentation for this class was generated from the following files:
Generated by   doxygen 1.8.13