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::Tensor_Base< ExpressionTemplate > Class Template Reference

#include <cmath.h>

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

Classes

struct  Alias
 
struct  nd_iterator_type
 
struct  nd_reverse_iterator_type
 

Public Types

using value_type = typename parent_type::value_type
 
using system_tag = typename parent_type::system_tag
 
using move_constructible = typename traits_type::is_move_constructible
 
using copy_constructible = typename traits_type::is_move_constructible
 
using move_assignable = typename traits_type::is_move_assignable
 
using copy_assignable = typename traits_type::is_copy_assignable
 
- Public Types inherited from bc::tensors::Expression_Base< ExpressionTemplate >
using value_type = typename ExpressionTemplate::value_type
 
using system_tag = typename ExpressionTemplate::system_tag
 

Public Member Functions

 Tensor_Base ()
 
 Tensor_Base (const expression_type &param)
 
 Tensor_Base (expression_type &&param)
 
template<class U >
 Tensor_Base (const Tensor_Base< U > &tensor)
 
 Tensor_Base (tensor_copy_type tensor)
 
 Tensor_Base (tensor_move_type tensor)
 
Tensor_Base & operator= (tensor_move_type tensor) noexcept
 
Tensor_Base & operator= (tensor_copy_type param)
 
template<class ValueType , class = std::enable_if_t<std::is_convertible<ValueType, value_type>::value && tensor_dim==0>>
 Tensor_Base (ValueType scalar)
 
auto begin () const
 
auto begin ()
 
auto cbegin () const
 
auto rbegin () const
 
auto rbegin ()
 
auto crbegin () const
 
auto end () const
 
auto end ()
 
auto cend () const
 
auto rend () const
 
auto rend ()
 
auto crend () const
 
template<class... params>
auto iter (params... ps) const
 
template<class... params>
auto iter (params... ps)
 
template<class... params>
auto const_iter (params... ps) const
 
template<class... params>
auto reverse_iter (params... ps) const
 
template<class... params>
auto reverse_iter (params... ps)
 
template<class... params>
auto reverse_const_iter (params... ps) const
 
template<class Xpr >
void copy (const Tensor_Base< Xpr > &rv)
 
std::string to_string (int precision=8, bool pretty=true, bool sparse=false) const
 
std::string to_raw_string (int precision=8) const
 
void print (int precision=8, bool pretty=true, bool sparse=false) const
 
void print_sparse (int precision=8, bool pretty=true) const
 
void raw_print (int precision=0, bool sparse=false) const
 
void print_dims () const
 
void print_leading_dims () const
 
self_type & fill (value_type value)
 
self_type & zero ()
 
self_type & ones ()
 
template<class Function >
void for_each (Function func) const
 
template<class Function >
void for_each (Function func)
 
self_type & sort ()
 
void randomize (value_type lb=0, value_type ub=1)
 
template<class Xpr >
self_type & operator= (const Expression_Base< Xpr > &param)
 
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type & operator= (const ScalarType &param)
 
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type & operator+= (const ScalarType &param)
 
template<class Xpr >
self_type & operator+= (const Expression_Base< Xpr > &param)
 
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type & operator-= (const ScalarType &param)
 
template<class Xpr >
self_type & operator-= (const Expression_Base< Xpr > &param)
 
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type & operator%= (const ScalarType &param)
 
template<class Xpr >
self_type & operator%= (const Expression_Base< Xpr > &param)
 
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type & operator/= (const ScalarType &param)
 
template<class Xpr >
self_type & operator/= (const Expression_Base< Xpr > &param)
 
Alias alias ()
 
 ~Tensor_Base ()
 
- Public Member Functions inherited from bc::tensors::Expression_Base< ExpressionTemplate >
 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 = parent_type::tensor_dim
 
static constexpr int tensor_iterator_dim = parent_type::tensor_iterator_dim
 
- Static Public Attributes inherited from bc::tensors::Expression_Base< ExpressionTemplate >
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
 
struct Alias
 
std::ostream & operator<< (std::ostream &os, const Tensor_Base &self)
 

Member Typedef Documentation

◆ copy_assignable

template<class ExpressionTemplate>
using bc::tensors::Tensor_Base< ExpressionTemplate >::copy_assignable = typename traits_type::is_copy_assignable

◆ copy_constructible

template<class ExpressionTemplate>
using bc::tensors::Tensor_Base< ExpressionTemplate >::copy_constructible = typename traits_type::is_move_constructible

◆ move_assignable

template<class ExpressionTemplate>
using bc::tensors::Tensor_Base< ExpressionTemplate >::move_assignable = typename traits_type::is_move_assignable

◆ move_constructible

template<class ExpressionTemplate>
using bc::tensors::Tensor_Base< ExpressionTemplate >::move_constructible = typename traits_type::is_move_constructible

◆ system_tag

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

◆ value_type

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

Constructor & Destructor Documentation

◆ Tensor_Base() [1/7]

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

◆ Tensor_Base() [2/7]

template<class ExpressionTemplate>
bc::tensors::Tensor_Base< ExpressionTemplate >::Tensor_Base ( const expression_type &  param)
inline

◆ Tensor_Base() [3/7]

template<class ExpressionTemplate>
bc::tensors::Tensor_Base< ExpressionTemplate >::Tensor_Base ( expression_type &&  param)
inline

◆ Tensor_Base() [4/7]

template<class ExpressionTemplate>
template<class U >
bc::tensors::Tensor_Base< ExpressionTemplate >::Tensor_Base ( const Tensor_Base< U > &  tensor)
inline

◆ Tensor_Base() [5/7]

template<class ExpressionTemplate>
bc::tensors::Tensor_Base< ExpressionTemplate >::Tensor_Base ( tensor_copy_type  tensor)
inline

◆ Tensor_Base() [6/7]

template<class ExpressionTemplate>
bc::tensors::Tensor_Base< ExpressionTemplate >::Tensor_Base ( tensor_move_type  tensor)
inline

◆ Tensor_Base() [7/7]

template<class ExpressionTemplate>
template<class ValueType , class = std::enable_if_t<std::is_convertible<ValueType, value_type>::value && tensor_dim==0>>
bc::tensors::Tensor_Base< ExpressionTemplate >::Tensor_Base ( ValueType  scalar)
inline

◆ ~Tensor_Base()

template<class ExpressionTemplate>
bc::tensors::Tensor_Base< ExpressionTemplate >::~Tensor_Base ( )
inline

Member Function Documentation

◆ alias()

template<class ExpressionTemplate>
Alias bc::tensors::Tensor_Base< ExpressionTemplate >::alias ( )
inline

◆ begin() [1/2]

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::begin ( ) const
inline

◆ begin() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::begin ( )
inline

◆ cbegin()

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::cbegin ( ) const
inline

◆ cend()

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::cend ( ) const
inline

◆ const_iter()

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

◆ copy()

template<class ExpressionTemplate>
template<class Xpr >
void bc::tensors::Tensor_Base< ExpressionTemplate >::copy ( const Tensor_Base< Xpr > &  rv)
inline

◆ crbegin()

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::crbegin ( ) const
inline

◆ crend()

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::crend ( ) const
inline

◆ end() [1/2]

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::end ( ) const
inline

◆ end() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::end ( )
inline

◆ fill()

template<class ExpressionTemplate>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::fill ( value_type  value)
inline

◆ for_each() [1/2]

template<class ExpressionTemplate>
template<class Function >
void bc::tensors::Tensor_Base< ExpressionTemplate >::for_each ( Function  func) const
inline

◆ for_each() [2/2]

template<class ExpressionTemplate>
template<class Function >
void bc::tensors::Tensor_Base< ExpressionTemplate >::for_each ( Function  func)
inline

◆ iter() [1/2]

template<class ExpressionTemplate>
template<class... params>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::iter ( params...  ps)
inline

◆ iter() [2/2]

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

◆ ones()

template<class ExpressionTemplate>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::ones ( )
inline

◆ operator%=() [1/2]

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

◆ operator%=() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::operator%= ( const ScalarType &  param)
inline

◆ operator+=() [1/2]

template<class ExpressionTemplate>
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::operator+= ( const ScalarType &  param)
inline

◆ operator+=() [2/2]

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

◆ operator-=() [1/2]

template<class ExpressionTemplate>
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::operator-= ( const ScalarType &  param)
inline

◆ operator-=() [2/2]

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

◆ operator/=() [1/2]

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

◆ operator/=() [2/2]

template<class ExpressionTemplate>
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::operator/= ( const ScalarType &  param)
inline

◆ operator=() [1/4]

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

◆ operator=() [2/4]

template<class ExpressionTemplate>
template<class ScalarType , class = enable_if_scalar<ScalarType>>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::operator= ( const ScalarType &  param)
inline

◆ operator=() [3/4]

template<class ExpressionTemplate>
Tensor_Base& bc::tensors::Tensor_Base< ExpressionTemplate >::operator= ( tensor_move_type  tensor)
inlinenoexcept

◆ operator=() [4/4]

template<class ExpressionTemplate>
Tensor_Base& bc::tensors::Tensor_Base< ExpressionTemplate >::operator= ( tensor_copy_type  param)
inline

◆ print()

template<class ExpressionTemplate>
void bc::tensors::Tensor_Base< ExpressionTemplate >::print ( int  precision = 8,
bool  pretty = true,
bool  sparse = false 
) const
inline

◆ print_dims()

template<class ExpressionTemplate>
void bc::tensors::Tensor_Base< ExpressionTemplate >::print_dims ( ) const
inline

◆ print_leading_dims()

template<class ExpressionTemplate>
void bc::tensors::Tensor_Base< ExpressionTemplate >::print_leading_dims ( ) const
inline

◆ print_sparse()

template<class ExpressionTemplate>
void bc::tensors::Tensor_Base< ExpressionTemplate >::print_sparse ( int  precision = 8,
bool  pretty = true 
) const
inline

◆ randomize()

template<class ExpressionTemplate>
void bc::tensors::Tensor_Base< ExpressionTemplate >::randomize ( value_type  lb = 0,
value_type  ub = 1 
)
inline

◆ raw_print()

template<class ExpressionTemplate>
void bc::tensors::Tensor_Base< ExpressionTemplate >::raw_print ( int  precision = 0,
bool  sparse = false 
) const
inline

◆ rbegin() [1/2]

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::rbegin ( )
inline

◆ rbegin() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::rbegin ( ) const
inline

◆ rend() [1/2]

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::rend ( )
inline

◆ rend() [2/2]

template<class ExpressionTemplate>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::rend ( ) const
inline

◆ reverse_const_iter()

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

◆ reverse_iter() [1/2]

template<class ExpressionTemplate>
template<class... params>
auto bc::tensors::Tensor_Base< ExpressionTemplate >::reverse_iter ( params...  ps)
inline

◆ reverse_iter() [2/2]

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

◆ sort()

template<class ExpressionTemplate>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::sort ( )
inline

◆ to_raw_string()

template<class ExpressionTemplate>
std::string bc::tensors::Tensor_Base< ExpressionTemplate >::to_raw_string ( int  precision = 8) const
inline

◆ to_string()

template<class ExpressionTemplate>
std::string bc::tensors::Tensor_Base< ExpressionTemplate >::to_string ( int  precision = 8,
bool  pretty = true,
bool  sparse = false 
) const
inline

◆ zero()

template<class ExpressionTemplate>
self_type& bc::tensors::Tensor_Base< ExpressionTemplate >::zero ( )
inline

Friends And Related Function Documentation

◆ Alias

template<class ExpressionTemplate>
friend struct Alias
friend

◆ operator<<

template<class ExpressionTemplate>
std::ostream& operator<< ( std::ostream &  os,
const Tensor_Base< ExpressionTemplate > &  self 
)
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::Tensor_Base< ExpressionTemplate >::tensor_dim = parent_type::tensor_dim
static

◆ tensor_iterator_dim

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