Namespaces
	cublas

	cufft

	evaluator

	internal

	shape_evaluator

	strict

Classes
struct	adapter

struct	adapter< blaze::DynamicMatrix< Type, SO > >

struct	adapter< blaze::DynamicVector< Type, TF > >

class	allocator

struct	assert_mat_trans_expr

struct	assert_mat_trans_expr_t

class	column_view

class	cudamalloc_resource

class	dense_matrix

class	dense_vector

class	device_matrix

class	device_memory_resource

struct	device_value_type

struct	device_value_type< complex< double > >

struct	device_value_type< complex< float > >

struct	device_value_type< half >

class	device_vector

struct	dmat_expr

struct	dvec_expr

struct	eval_context

class	expression

struct	generic_expr

class	global_context

struct	has_shape

struct	is_mat_mat_mult_expr

struct	is_mat_mat_mult_expr< mat_mat_mult_expr< LhsExpr, RhsExpr > >

struct	is_mat_trans_expr

struct	is_mat_trans_expr< trans< GpuMat > >

struct	is_scalar

struct	is_scalar< std::complex< T > >

struct	is_supported_type

struct	is_supported_type< double >

struct	is_supported_type< float >

struct	is_supported_type< std::complex< double > >

struct	is_supported_type< std::complex< float > >

class	matrix

struct	matrix_base

class	memory_resource

class	new_delete_resource

struct	scalar_expr

struct	shape

struct	shape_expr

struct	static_any

class	thread_context

class	thread_guard

struct	tie_expr

struct	value_type

struct	value_type< complex< Type > >

struct	vector_base

Typedefs
template<typename T , typename U >
using	hash_table = std::unordered_map< T, U >

using	free_mem_t = size_t

using	total_mem_t = size_t

template<typename Expr >
using	zeros_mat_expr = generic_expr< zeros_mat_expr_type, 0, dmat_expr, typename Expr::result_type, 1, symbolic_shape_expr< Expr > >

template<typename Expr >
using	ones_mat_expr = generic_expr< ones_mat_expr_type, 0, dmat_expr, typename Expr::result_type, 1, symbolic_shape_expr< Expr > >

template<typename Expr >
using	zeros_vec_expr = generic_expr< zeros_vec_expr_type, 0, dvec_expr, typename Expr::result_type, 1, symbolic_shape_expr< Expr > >

template<typename Expr >
using	ones_vec_expr = generic_expr< ones_vec_expr_type, 0, dvec_expr, typename Expr::result_type, 1, symbolic_shape_expr< Expr > >

template<typename LhsExpr , typename RhsExpr >
using	dmat_dmat_add_expr = binary_expr< dmat_dmat_add_expr_type, dmat_expr, typename LhsExpr::result_type, LhsExpr, RhsExpr >

template<typename LhsExpr , typename RhsExpr >
using	dmat_dmat_mult_expr = binary_expr< dmat_dmat_mult_expr_type, dmat_expr, typename LhsExpr::result_type, LhsExpr, RhsExpr >

template<typename MatExpr , typename VecExpr >
using	dmat_dvec_mult_expr = binary_expr< dmat_dvec_mult_expr_type, dvec_expr, typename VecExpr::result_type, MatExpr, VecExpr >

template<typename Expr >
using	dmat_reduce_sum_expr = generic_expr< dmat_reduce_sum_expr_type, 0, scalar_expr, typename Expr::result_type::value_type, 0, Expr >

template<typename Expr >
using	dmat_reduce_mean_expr = generic_expr< dmat_reduce_mean_expr_type, 0, scalar_expr, typename Expr::result_type::value_type, 0, Expr >

template<typename Matrix >
using	dmat_ref_expr = generic_expr< dmat_ref_expr_type, 0, dmat_expr, Matrix, 1, Matrix const & >

template<typename Expr >
using	dmat_trans_expr = unary_expr< dmat_trans_expr_type, dmat_expr, typename Expr::result_type, Expr >

template<typename LhsExpr , typename RhsExpr >
using	dvec_dvec_add_expr = binary_expr< dvec_dvec_add_expr_type, dvec_expr, typename LhsExpr::result_type, LhsExpr, RhsExpr >

template<typename LhsExpr , typename RhsExpr >
using	dvec_dvec_outer_expr = binary_expr< dvec_dvec_outer_expr_type, dmat_expr, device_matrix< typename LhsExpr::result_type::value_type >, LhsExpr, RhsExpr >

template<typename Expr >
using	dvec_map_expr = generic_expr< dmat_mat_expr_type, 0, dvec_expr, typename Expr::result_type, 1, typename Expr::result_type(*)(typename Expr::result_type::parent_type const &vec), Expr >

template<typename Expr >
using	dvec_reduce_sum_expr = generic_expr< dvec_reduce_sum_expr_type, 0, scalar_expr, typename Expr::result_type::value_type, 0, Expr >

template<typename Expr >
using	dvec_reduce_mean_expr = generic_expr< dvec_reduce_mean_expr_type, 0, scalar_expr, typename Expr::result_type::value_type, 0, Expr >

template<typename Vector >
using	dvec_ref_expr = generic_expr< dvec_ref_expr_type, 0, dvec_expr, Vector, 1, Vector const & >

template<typename TagType , template< typename > class ResultExprType, typename ResultType , typename Expr >
using	unary_expr = generic_expr< TagType, 0, ResultExprType, ResultType, 0, Expr >

template<typename TagType , template< typename > class ResultExprType, typename ResultType , typename LhsExpr , typename RhsExpr >
using	binary_expr = generic_expr< TagType, 0, ResultExprType, ResultType, 0, LhsExpr, RhsExpr >

template<size_t PlaceholderID, typename ResultType >
using	placeholder_node = generic_expr< placeholder_node_type, PlaceholderID, ResultType::template result_expr_type, ResultType, 0 >

template<typename ScalExpr , typename DMatExpr >
using	scalar_dmat_mult_expr = binary_expr< scalar_dmat_mult_expr_type, dmat_expr, typename DMatExpr::result_type, ScalExpr, DMatExpr >

template<typename ScalExpr , typename DVecExpr >
using	scalar_dvec_mult_expr = binary_expr< scalar_dvec_mult_expr_type, dvec_expr, typename DVecExpr::result_type, ScalExpr, DVecExpr >

template<typename T >
using	scalar_constant_expr = generic_expr< scalar_constant_expr_type, 0, scalar_expr, T, 1, T >

template<typename T >
using	scalar_zero_constant_expr = generic_expr< scalar_zero_constant_expr_type, 0, scalar_expr, T, 0 >

template<typename T >
using	scalar_one_constant_expr = generic_expr< scalar_one_constant_expr_type, 0, scalar_expr, T, 0 >

template<typename Expr >
using	symbolic_shape_expr = generic_expr< symbolic_shape_expr_type, 0, shape_expr, typename Expr::result_type::shape_type, 1, Expr >

template<typename... Exprs>
using	tie_op = generic_expr< tie_op_type, 0, tie_expr, std::tuple< typename Exprs::result_type... >, 0, Exprs... >

template<typename Type >
using	complex = std::complex< Type >

using	pad_size_t = std::pair< size_t, size_t >

typedef cublasStatus_t	cublas_error_t

typedef cudaError_t	cuda_error_t

using	cufft_error_t = cufftResult

template<typename... Args>
using	void_t = void

Enumerations
enum	byte : unsigned char

enum	cuda_memcpy_kind { cuda_memcpy_kind::host_to_device = cudaMemcpyKind::cudaMemcpyHostToDevice, cuda_memcpy_kind::device_to_host = cudaMemcpyKind::cudaMemcpyDeviceToHost, cuda_memcpy_kind::device_to_device = cudaMemcpyKind::cudaMemcpyDeviceToDevice }

enum	mgblas_error_t { success = 0, index_out_of_range = 1, invalid_range = 2, memory_allocation_failure = 3, device_to_host_memcpy_failure = 4 }

enum	fft_direction { fft_direction::forward, fft_direction::inverse }
	FFT direction. More...

enum	status_t { status_t::success = 0 }

Functions
template<typename T1 , typename T2 >
bool	operator== (allocator< T1 > const &a, allocator< T2 > const &b)

template<typename T1 , typename T2 >
bool	operator!= (allocator< T1 > const &a, allocator< T2 > const &b)

bool	operator== (const memory_resource &a, const memory_resource &b)

bool	operator!= (const memory_resource &a, const memory_resource &b)

outcome::result< void >	cuda_set_device (size_t device_id) noexcept

template<typename ElemType >
outcome::result< ElemType * >	cuda_malloc (size_t size) noexcept

template<typename ElemType >
outcome::result< void >	cuda_free (ElemType *ptr) noexcept

template<typename ElemType >
outcome::result< void >	cuda_memset_to_zero (ElemType *ptr, size_t count) noexcept

template<typename ElemType >
outcome::result< ElemType * >	malloc_pinned (size_t count) noexcept

template<typename ElemType >
outcome::result< void >	free_pinned (ElemType *ptr) noexcept

template<typename ElemType >
outcome::result< void >	cuda_memcpy (ElemType to, ElemType const from, size_t count, cuda_memcpy_kind kind) noexcept

outcome::result< void >	cuda_memcpy (cuComplex to, std::complex< float > const from, size_t count, cuda_memcpy_kind kind) noexcept

outcome::result< void >	cuda_memcpy (std::complex< float > to, cuComplex const from, size_t count, cuda_memcpy_kind kind) noexcept

outcome::result< void >	cuda_memcpy (cuDoubleComplex to, std::complex< double > const from, size_t count, cuda_memcpy_kind kind) noexcept

outcome::result< void >	cuda_memcpy (std::complex< double > to, cuDoubleComplex const from, size_t count, cuda_memcpy_kind kind) noexcept

outcome::result< std::pair< free_mem_t, total_mem_t > >	cuda_mem_get_info () noexcept

template<typename Expr >
zeros_mat_expr< Expr >	make_zeros_like (dmat_expr< Expr > const &expr)

template<typename Expr >
ones_mat_expr< Expr >	make_ones_like (dmat_expr< Expr > const &expr)

template<typename Expr >
zeros_vec_expr< Expr >	make_zeros_like (dvec_expr< Expr > const &expr)

template<typename Expr >
ones_vec_expr< Expr >	make_ones_like (dvec_expr< Expr > const &expr)

template<typename LhsExpr , typename RhsExpr >
auto	operator+ (dmat_expr< LhsExpr > const &lhs, dmat_expr< RhsExpr > const &rhs) noexcept

template<typename LhsExpr , typename RhsExpr >
auto	add (dmat_expr< LhsExpr > const &lhs, dmat_expr< RhsExpr > const &rhs) noexcept

template<typename LhsExpr , typename RhsExpr >
auto	operator- (dmat_expr< LhsExpr > const &lhs, dmat_expr< RhsExpr > const &rhs) noexcept

template<typename LhsExpr , typename RhsExpr >
auto	sub (dmat_expr< LhsExpr > const &lhs, dmat_expr< RhsExpr > const &rhs) noexcept

template<typename LhsExpr , typename RhsExpr >
dmat_dmat_mult_expr< LhsExpr, RhsExpr >	operator* (dmat_expr< LhsExpr > const &lhs, dmat_expr< RhsExpr > const &rhs) noexcept

template<typename LhsExpr , typename RhsExpr >
dmat_dmat_mult_expr< LhsExpr, RhsExpr >	mult (dmat_expr< LhsExpr > const &lhs, dmat_expr< RhsExpr > const &rhs) noexcept

template<typename MatExpr , typename VecExpr >
dmat_dvec_mult_expr< MatExpr, VecExpr >	operator* (dmat_expr< MatExpr > const &mat, dvec_expr< VecExpr > const &vec) noexcept

template<typename MatExpr , typename VecExpr >
dmat_dvec_mult_expr< MatExpr, VecExpr >	mult (dmat_expr< MatExpr > const &mat, dvec_expr< VecExpr > const &vec) noexcept

template<typename Expr >
decltype(auto)	reduce_sum (dmat_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	reduce_mean (dmat_expr< Expr > const &expr) noexcept

template<typename DenseMatrix , typename Type >
dmat_ref_expr< DenseMatrix >	ref (dense_matrix< DenseMatrix, Type > const &mat)

template<typename Expr >
dmat_trans_expr< Expr >	trans (dmat_expr< Expr > const &expr) noexcept

template<typename LhsExpr , typename RhsExpr >
dvec_dvec_add_expr< LhsExpr, RhsExpr >	operator+ (dvec_expr< LhsExpr > const &lhs, dvec_expr< RhsExpr > const &rhs) noexcept

template<typename LhsExpr , typename RhsExpr >
dvec_dvec_add_expr< LhsExpr, RhsExpr >	add (dvec_expr< LhsExpr > const &lhs, dvec_expr< RhsExpr > const &rhs) noexcept

template<typename LhsExpr , typename RhsExpr >
auto	outer (dvec_expr< LhsExpr > const &lhs, dvec_expr< RhsExpr > const &rhs) noexcept

template<typename Expr >
decltype(auto)	abs (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	sin (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	cos (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	tan (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	sinh (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	cosh (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	tanh (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	relu (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	reduce_sum (dvec_expr< Expr > const &expr) noexcept

template<typename Expr >
decltype(auto)	reduce_mean (dvec_expr< Expr > const &expr) noexcept

template<typename DenseVector , typename Type >
dvec_ref_expr< DenseVector >	ref (dense_vector< DenseVector, Type > const &mat)

size_t	get_last_run_cache_hits ()

void	analyze_graph (size_t id, std::function< void()> traverse)

static_any	evaluate_if_needed (size_t id, bool needs_caching, std::function< void()> traverse, std::function< static_any()> evaluate)

template<typename T >
T::result_type	eval (expression< T > const &expr, eval_context const &ctx)

template<typename T >
T::result_type	eval (expression< T > const &expr)

size_t	make_id ()

template<typename Expr , size_t PlaceholderID, typename PhResultType >
auto	grad (scalar_expr< Expr > const &expr, placeholder_node< PlaceholderID, PhResultType > wrt)

template<typename Expr >
std::ostream &	operator<< (std::ostream &os, expression< Expr > const &expr)

template<typename Scalar , typename DMatExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>
auto	operator* (Scalar const &scalar, dmat_expr< DMatExpr > const &exp) noexcept

template<typename Scalar , typename DMatExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>
auto	operator* (dmat_expr< DMatExpr > const &exp, Scalar const &scalar) noexcept

template<typename ScalExpr , typename DMatExpr >
auto	operator* (scalar_expr< ScalExpr > const &scalar, dmat_expr< DMatExpr > const &exp) noexcept

template<typename ScalExpr , typename DMatExpr >
auto	operator* (dmat_expr< DMatExpr > const &exp, scalar_expr< ScalExpr > const &scalar) noexcept

template<typename Scalar , typename DMatExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>
auto	mult (Scalar const &scalar, dmat_expr< DMatExpr > const &mat_exp) noexcept

template<typename Scalar , typename DMatExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>
auto	mult (dmat_expr< DMatExpr > const &mat_exp, Scalar const &scalar) noexcept

template<typename ScalExpr , typename DMatExpr >
auto	mult (scalar_expr< ScalExpr > const &scalar, dmat_expr< DMatExpr > const &mat_exp) noexcept

template<typename ScalExpr , typename DMatExpr >
auto	mult (dmat_expr< DMatExpr > const &mat_exp, scalar_expr< ScalExpr > const &scalar) noexcept

template<typename Scalar , typename DVecExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>
auto	operator* (Scalar const &scalar, dvec_expr< DVecExpr > const &exp) noexcept

template<typename Scalar , typename DVecExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>
auto	operator* (dvec_expr< DVecExpr > const &exp, Scalar const &scalar) noexcept

template<typename ScalExpr , typename DVecExpr >
auto	operator* (scalar_expr< ScalExpr > const &scalar, dvec_expr< DVecExpr > const &exp) noexcept

template<typename ScalExpr , typename DVecExpr >
auto	operator* (dvec_expr< DVecExpr > const &exp, scalar_expr< ScalExpr > const &scalar) noexcept

template<typename Scalar , typename DVecExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>
auto	mult (Scalar const &scalar, dvec_expr< DVecExpr > const &vec_exp) noexcept

template<typename Scalar , typename DVecExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>
auto	mult (dvec_expr< DVecExpr > const &vec_exp, Scalar const &scalar) noexcept

template<typename ScalExpr , typename DVecExpr >
auto	mult (scalar_expr< ScalExpr > const &scalar, dvec_expr< DVecExpr > const &vec_exp) noexcept

template<typename ScalExpr , typename DVecExpr >
auto	mult (dvec_expr< DVecExpr > const &vec_exp, scalar_expr< ScalExpr > const &scalar) noexcept

template<typename Type >
scalar_constant_expr< Type >	scal (Type scalar)

template<typename Expr >
symbolic_shape_expr< Expr >	sym_shape (Expr const &expr)

template<typename... Exprs>
tie_op< Exprs... >	tie (Exprs const &... exprs)

void	init (bool print_system_info=true)

template<typename... Types>
shape< sizeof...(Types)>	make_shape (Types... args)

template<class Tuple , class F >
decltype(auto) constexpr	apply (Tuple &&t, F &&f)

template<class Tuple , class F >
constexpr void	apply_void (Tuple &&t, F &&f)

template<size_t N, class Tuple >
decltype(auto) constexpr	take_front (Tuple &&t)

template<size_t N, class Tuple >
decltype(auto) constexpr	take_rest (Tuple &&t)

template<class Tuple >
decltype(auto) constexpr	sum_tuple (Tuple &&t)

template<class Tuple1 , class Tuple2 >
decltype(auto) constexpr	zip (Tuple1 &&t1, Tuple2 &&t2)

template<class Tuple >
decltype(auto) constexpr	enumerate (Tuple &&t)

template<typename Type >
outcome::result< void >	mgblas_fill (Type *arr, Type value, size_t n)

template<typename From , typename To >
outcome::result< void >	mgblas_convert_copy (From const from, To to, size_t n)

template<typename T >
outcome::result< void >	mgblas_vhp (T const x, T const y, T *z, size_t n)

template<typename T >
outcome::result< void >	mgblas_vab (T *x, size_t n)

template<typename T >
outcome::result< void >	mgblas_vpr (T const x, T y, size_t n)

template<typename T >
outcome::result< void >	mgblas_vsin (T *x, size_t n)

template<typename T >
outcome::result< void >	mgblas_vcos (T *x, size_t n)

template<typename T >
outcome::result< void >	mgblas_vtan (T *x, size_t n)

template<typename T >
outcome::result< void >	mgblas_vsinh (T *x, size_t n)

template<typename T >
outcome::result< void >	mgblas_vcosh (T *x, size_t n)

template<typename T >
outcome::result< void >	mgblas_vtanh (T *x, size_t n)

template<typename T >
outcome::result< void >	mgblas_vrelu (T *x, size_t n)

bool	ASSERT_MESSAGE (char const *message)

std::error_condition	make_error_condition (mgcpp::status_t err) noexcept

std::error_code	make_error_code (mgcpp::mgblas_error_t err) noexcept

template<typename To , typename From >
To	pun_cast (From const *from)

template<typename To , typename From >
To	pun_cast (From *from)

Typedef Documentation

◆ binary_expr

template<typename TagType , template< typename > class ResultExprType, typename ResultType , typename LhsExpr , typename RhsExpr >

using mgcpp::binary_expr = typedef generic_expr<TagType, 0, ResultExprType, ResultType, 0, LhsExpr, RhsExpr>

◆ complex

template<typename Type >

using mgcpp::complex = typedef std::complex<Type>

◆ cublas_error_t

typedef cublasStatus_t mgcpp::cublas_error_t

◆ cuda_error_t

typedef cudaError_t mgcpp::cuda_error_t

◆ cufft_error_t

using mgcpp::cufft_error_t = typedef cufftResult

◆ dmat_dmat_add_expr

template<typename LhsExpr , typename RhsExpr >

using mgcpp::dmat_dmat_add_expr = typedef binary_expr<dmat_dmat_add_expr_type, dmat_expr, typename LhsExpr::result_type, LhsExpr, RhsExpr>

◆ dmat_dmat_mult_expr

template<typename LhsExpr , typename RhsExpr >

using mgcpp::dmat_dmat_mult_expr = typedef binary_expr<dmat_dmat_mult_expr_type, dmat_expr, typename LhsExpr::result_type, LhsExpr, RhsExpr>

◆ dmat_dvec_mult_expr

template<typename MatExpr , typename VecExpr >

using mgcpp::dmat_dvec_mult_expr = typedef binary_expr<dmat_dvec_mult_expr_type, dvec_expr, typename VecExpr::result_type, MatExpr, VecExpr>

◆ dmat_reduce_mean_expr

template<typename Expr >

using mgcpp::dmat_reduce_mean_expr = typedef generic_expr<dmat_reduce_mean_expr_type, 0, scalar_expr, typename Expr::result_type::value_type, 0, Expr>

◆ dmat_reduce_sum_expr

template<typename Expr >

using mgcpp::dmat_reduce_sum_expr = typedef generic_expr<dmat_reduce_sum_expr_type, 0, scalar_expr, typename Expr::result_type::value_type, 0, Expr>

◆ dmat_ref_expr

template<typename Matrix >

using mgcpp::dmat_ref_expr = typedef generic_expr<dmat_ref_expr_type, 0, dmat_expr, Matrix, 1, Matrix const&>

◆ dmat_trans_expr

template<typename Expr >

using mgcpp::dmat_trans_expr = typedef unary_expr<dmat_trans_expr_type, dmat_expr, typename Expr::result_type, Expr>

◆ dvec_dvec_add_expr

template<typename LhsExpr , typename RhsExpr >

using mgcpp::dvec_dvec_add_expr = typedef binary_expr<dvec_dvec_add_expr_type, dvec_expr, typename LhsExpr::result_type, LhsExpr, RhsExpr>

◆ dvec_dvec_outer_expr

template<typename LhsExpr , typename RhsExpr >

using mgcpp::dvec_dvec_outer_expr = typedef binary_expr<dvec_dvec_outer_expr_type, dmat_expr, device_matrix<typename LhsExpr::result_type::value_type>, LhsExpr, RhsExpr>

◆ dvec_map_expr

template<typename Expr >

using mgcpp::dvec_map_expr = typedef generic_expr<dmat_mat_expr_type, 0, dvec_expr, typename Expr::result_type, 1, typename Expr::result_type (*)( typename Expr::result_type::parent_type const& vec), Expr>

◆ dvec_reduce_mean_expr

template<typename Expr >

using mgcpp::dvec_reduce_mean_expr = typedef generic_expr<dvec_reduce_mean_expr_type, 0, scalar_expr, typename Expr::result_type::value_type, 0, Expr>

◆ dvec_reduce_sum_expr

template<typename Expr >

using mgcpp::dvec_reduce_sum_expr = typedef generic_expr<dvec_reduce_sum_expr_type, 0, scalar_expr, typename Expr::result_type::value_type, 0, Expr>

◆ dvec_ref_expr

template<typename Vector >

using mgcpp::dvec_ref_expr = typedef generic_expr<dvec_ref_expr_type, 0, dvec_expr, Vector, 1, Vector const&>

◆ free_mem_t

using mgcpp::free_mem_t = typedef size_t

◆ hash_table

template<typename T , typename U >

using mgcpp::hash_table = typedef std::unordered_map<T, U>

◆ ones_mat_expr

template<typename Expr >

using mgcpp::ones_mat_expr = typedef generic_expr<ones_mat_expr_type, 0, dmat_expr, typename Expr::result_type, 1, symbolic_shape_expr<Expr> >

◆ ones_vec_expr

template<typename Expr >

using mgcpp::ones_vec_expr = typedef generic_expr<ones_vec_expr_type, 0, dvec_expr, typename Expr::result_type, 1, symbolic_shape_expr<Expr> >

◆ pad_size_t

using mgcpp::pad_size_t = typedef std::pair<size_t, size_t>

pad_size_t::first : pad before amount pad_size_t::second : pad after amount

◆ placeholder_node

template<size_t PlaceholderID, typename ResultType >

using mgcpp::placeholder_node = typedef generic_expr<placeholder_node_type, PlaceholderID, ResultType::template result_expr_type, ResultType, 0>

◆ scalar_constant_expr

template<typename T >

using mgcpp::scalar_constant_expr = typedef generic_expr<scalar_constant_expr_type, 0, scalar_expr, T, 1, T>

◆ scalar_dmat_mult_expr

template<typename ScalExpr , typename DMatExpr >

using mgcpp::scalar_dmat_mult_expr = typedef binary_expr<scalar_dmat_mult_expr_type, dmat_expr, typename DMatExpr::result_type, ScalExpr, DMatExpr>

◆ scalar_dvec_mult_expr

template<typename ScalExpr , typename DVecExpr >

using mgcpp::scalar_dvec_mult_expr = typedef binary_expr<scalar_dvec_mult_expr_type, dvec_expr, typename DVecExpr::result_type, ScalExpr, DVecExpr>

◆ scalar_one_constant_expr

template<typename T >

using mgcpp::scalar_one_constant_expr = typedef generic_expr<scalar_one_constant_expr_type, 0, scalar_expr, T, 0>

◆ scalar_zero_constant_expr

template<typename T >

using mgcpp::scalar_zero_constant_expr = typedef generic_expr<scalar_zero_constant_expr_type, 0, scalar_expr, T, 0>

◆ symbolic_shape_expr

template<typename Expr >

using mgcpp::symbolic_shape_expr = typedef generic_expr<symbolic_shape_expr_type, 0, shape_expr, typename Expr::result_type::shape_type, 1, Expr>

◆ tie_op

template<typename... Exprs>

using mgcpp::tie_op = typedef generic_expr<tie_op_type, 0, tie_expr, std::tuple<typename Exprs::result_type...>, 0, Exprs...>

◆ total_mem_t

using mgcpp::total_mem_t = typedef size_t

◆ unary_expr

template<typename TagType , template< typename > class ResultExprType, typename ResultType , typename Expr >

using mgcpp::unary_expr = typedef generic_expr<TagType, 0, ResultExprType, ResultType, 0, Expr>

◆ void_t

template<typename... Args>

using mgcpp::void_t = typedef void

◆ zeros_mat_expr

template<typename Expr >

using mgcpp::zeros_mat_expr = typedef generic_expr<zeros_mat_expr_type, 0, dmat_expr, typename Expr::result_type, 1, symbolic_shape_expr<Expr> >

◆ zeros_vec_expr

template<typename Expr >

using mgcpp::zeros_vec_expr = typedef generic_expr<zeros_vec_expr_type, 0, dvec_expr, typename Expr::result_type, 1, symbolic_shape_expr<Expr> >

Enumeration Type Documentation

◆ byte

enum mgcpp::byte : unsigned char

strong

◆ cuda_memcpy_kind

enum mgcpp::cuda_memcpy_kind

strong

Enumerator
host_to_device
device_to_host
device_to_device

◆ fft_direction

enum mgcpp::fft_direction

strong

FFT direction.

Enumerator
forward	Forward FFT.
inverse	Inverse FFT.

◆ mgblas_error_t

enum mgcpp::mgblas_error_t

Enumerator
success
index_out_of_range
invalid_range
memory_allocation_failure
device_to_host_memcpy_failure

◆ status_t

enum mgcpp::status_t

strong

Enumerator
success

Function Documentation

◆ abs()

template<typename Expr >

decltype(auto) mgcpp::abs ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ add() [1/2]

template<typename LhsExpr , typename RhsExpr >

auto mgcpp::add	(	dmat_expr< LhsExpr > const &	lhs,
		dmat_expr< RhsExpr > const &	rhs
	)

inlinenoexcept

◆ add() [2/2]

template<typename LhsExpr , typename RhsExpr >

dvec_dvec_add_expr<LhsExpr, RhsExpr> mgcpp::add	(	dvec_expr< LhsExpr > const &	lhs,
		dvec_expr< RhsExpr > const &	rhs
	)

inlinenoexcept

Returns a dense vector addition expression.

Parameters

lhs	the left-hand side dense vector
rhs	the right-hand side dense vector

◆ analyze_graph()

void mgcpp::analyze_graph	(	size_t	id,
		std::function< void()>	traverse
	)

◆ apply()

template<class Tuple , class F >

decltype(auto) constexpr mgcpp::apply	(	Tuple &&	t,
		F &&	f
	)

◆ apply_void()

template<class Tuple , class F >

constexpr void mgcpp::apply_void	(	Tuple &&	t,
		F &&	f
	)

◆ ASSERT_MESSAGE()

bool mgcpp::ASSERT_MESSAGE ( char const * message )

inline

◆ cos()

template<typename Expr >

decltype(auto) mgcpp::cos ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ cosh()

template<typename Expr >

decltype(auto) mgcpp::cosh ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ cuda_free()

template<typename ElemType >

outcome::result<void> mgcpp::cuda_free ( ElemType * ptr )

noexcept

◆ cuda_malloc()

template<typename ElemType >

outcome::result<ElemType*> mgcpp::cuda_malloc ( size_t size )

noexcept

◆ cuda_mem_get_info()

outcome::result<std::pair<free_mem_t, total_mem_t> > mgcpp::cuda_mem_get_info ( )

inlinenoexcept

◆ cuda_memcpy() [1/5]

template<typename ElemType >

outcome::result<void> mgcpp::cuda_memcpy	(	ElemType *	to,
		ElemType const *	from,
		size_t	count,
		cuda_memcpy_kind	kind
	)

noexcept

◆ cuda_memcpy() [2/5]

outcome::result<void> mgcpp::cuda_memcpy	(	cuComplex *	to,
		std::complex< float > const *	from,
		size_t	count,
		cuda_memcpy_kind	kind
	)

inlinenoexcept

◆ cuda_memcpy() [3/5]

outcome::result<void> mgcpp::cuda_memcpy	(	std::complex< float > *	to,
		cuComplex const *	from,
		size_t	count,
		cuda_memcpy_kind	kind
	)

inlinenoexcept

◆ cuda_memcpy() [4/5]

outcome::result<void> mgcpp::cuda_memcpy	(	cuDoubleComplex *	to,
		std::complex< double > const *	from,
		size_t	count,
		cuda_memcpy_kind	kind
	)

inlinenoexcept

◆ cuda_memcpy() [5/5]

outcome::result<void> mgcpp::cuda_memcpy	(	std::complex< double > *	to,
		cuDoubleComplex const *	from,
		size_t	count,
		cuda_memcpy_kind	kind
	)

inlinenoexcept

◆ cuda_memset_to_zero()

template<typename ElemType >

outcome::result<void> mgcpp::cuda_memset_to_zero	(	ElemType *	ptr,
		size_t	count
	)

noexcept

◆ cuda_set_device()

outcome::result<void> mgcpp::cuda_set_device ( size_t device_id )

noexcept

◆ enumerate()

template<class Tuple >

decltype(auto) constexpr mgcpp::enumerate ( Tuple && t )

◆ eval() [1/2]

template<typename T >

T::result_type mgcpp::eval	(	expression< T > const &	expr,
		eval_context const &	ctx
	)

inline

◆ eval() [2/2]

template<typename T >

T::result_type mgcpp::eval ( expression< T > const & expr )

inline

◆ evaluate_if_needed()

static_any mgcpp::evaluate_if_needed	(	size_t	id,
		bool	needs_caching,
		std::function< void()>	traverse,
		std::function< static_any()>	evaluate
	)

◆ free_pinned()

template<typename ElemType >

outcome::result<void> mgcpp::free_pinned ( ElemType * ptr )

noexcept

◆ get_last_run_cache_hits()

size_t mgcpp::get_last_run_cache_hits ( )

◆ grad()

template<typename Expr , size_t PlaceholderID, typename PhResultType >

auto mgcpp::grad	(	scalar_expr< Expr > const &	expr,
		placeholder_node< PlaceholderID, PhResultType >	wrt
	)

inline

◆ init()

void mgcpp::init ( bool print_system_info = true )

◆ make_error_code()

std::error_code mgcpp::make_error_code ( mgcpp::mgblas_error_t err )

noexcept

◆ make_error_condition()

std::error_condition mgcpp::make_error_condition ( mgcpp::status_t err )

noexcept

◆ make_id()

size_t mgcpp::make_id ( )

◆ make_ones_like() [1/2]

template<typename Expr >

ones_mat_expr<Expr> mgcpp::make_ones_like ( dmat_expr< Expr > const & expr )

◆ make_ones_like() [2/2]

template<typename Expr >

ones_vec_expr<Expr> mgcpp::make_ones_like ( dvec_expr< Expr > const & expr )

◆ make_shape()

template<typename... Types>

shape<sizeof...(Types)> mgcpp::make_shape ( Types... args )

◆ make_zeros_like() [1/2]

template<typename Expr >

zeros_mat_expr<Expr> mgcpp::make_zeros_like ( dmat_expr< Expr > const & expr )

◆ make_zeros_like() [2/2]

template<typename Expr >

zeros_vec_expr<Expr> mgcpp::make_zeros_like ( dvec_expr< Expr > const & expr )

◆ malloc_pinned()

template<typename ElemType >

outcome::result<ElemType*> mgcpp::malloc_pinned ( size_t count )

noexcept

◆ mgblas_convert_copy()

template<typename From , typename To >

outcome::result<void> mgcpp::mgblas_convert_copy	(	From const *	from,
		To *	to,
		size_t	n
	)

inline

◆ mgblas_fill()

template<typename Type >

outcome::result<void> mgcpp::mgblas_fill	(	Type *	arr,
		Type	value,
		size_t	n
	)

inline

◆ mgblas_vab()

template<typename T >

outcome::result<void> mgcpp::mgblas_vab	(	T *	x,
		size_t	n
	)

inline

Absolute value

Parameters

x	x
n	number of elements

◆ mgblas_vcos()

template<typename T >

outcome::result<void> mgcpp::mgblas_vcos	(	T *	x,
		size_t	n
	)

inline

◆ mgblas_vcosh()

template<typename T >

outcome::result<void> mgcpp::mgblas_vcosh	(	T *	x,
		size_t	n
	)

inline

◆ mgblas_vhp()

template<typename T >

outcome::result<void> mgcpp::mgblas_vhp	(	T const *	x,
		T const *	y,
		T *	z,
		size_t	n
	)

inline

Hadamard product

Parameters

x	x
y	y
z	pointer to the result
n	number of elements

◆ mgblas_vpr()

template<typename T >

outcome::result<void> mgcpp::mgblas_vpr	(	T const *	x,
		T *	y,
		size_t	n
	)

inline

Calculates the sum of all elements

Parameters

x	x
y	result
n	number of elements

◆ mgblas_vrelu()

template<typename T >

outcome::result<void> mgcpp::mgblas_vrelu	(	T *	x,
		size_t	n
	)

inline

◆ mgblas_vsin()

template<typename T >

outcome::result<void> mgcpp::mgblas_vsin	(	T *	x,
		size_t	n
	)

inline

◆ mgblas_vsinh()

template<typename T >

outcome::result<void> mgcpp::mgblas_vsinh	(	T *	x,
		size_t	n
	)

inline

◆ mgblas_vtan()

template<typename T >

outcome::result<void> mgcpp::mgblas_vtan	(	T *	x,
		size_t	n
	)

inline

◆ mgblas_vtanh()

template<typename T >

outcome::result<void> mgcpp::mgblas_vtanh	(	T *	x,
		size_t	n
	)

inline

◆ mult() [1/10]

template<typename LhsExpr , typename RhsExpr >

dmat_dmat_mult_expr<LhsExpr, RhsExpr> mgcpp::mult	(	dmat_expr< LhsExpr > const &	lhs,
		dmat_expr< RhsExpr > const &	rhs
	)

inlinenoexcept

Returns a dense matrix product expression.

Parameters

lhs	the left-hand side dense matrix
rhs	the right-hand side dense matrix

◆ mult() [2/10]

template<typename MatExpr , typename VecExpr >

dmat_dvec_mult_expr<MatExpr, VecExpr> mgcpp::mult	(	dmat_expr< MatExpr > const &	mat,
		dvec_expr< VecExpr > const &	vec
	)

inlinenoexcept

Returns a dense matrix add expression.

Parameters

lhs	the left-hand side dense matrix
rhs	the right-hand side dense vector

◆ mult() [3/10]

template<typename Scalar , typename DVecExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>

auto mgcpp::mult	(	Scalar const &	scalar,
		dvec_expr< DVecExpr > const &	vec_exp
	)

inlinenoexcept

Returns a scalar, dense vector product expression.

Parameters

lhs	the left-hand side scalar variable
rhs	the right-hand side dense vector

◆ mult() [4/10]

template<typename Scalar , typename DMatExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>

auto mgcpp::mult	(	Scalar const &	scalar,
		dmat_expr< DMatExpr > const &	mat_exp
	)

inlinenoexcept

Returns a scalar, dense matrix product expression.

Parameters

lhs	the left-hand side scalar variable
rhs	the right-hand side dense matrix

◆ mult() [5/10]

template<typename Scalar , typename DVecExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>

auto mgcpp::mult	(	dvec_expr< DVecExpr > const &	vec_exp,
		Scalar const &	scalar
	)

inlinenoexcept

Returns a scalar, dense vector product expression.

Parameters

lhs	the left-hand side dense vector
rhs	the right-hand side scalar variable

◆ mult() [6/10]

template<typename Scalar , typename DMatExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>

auto mgcpp::mult	(	dmat_expr< DMatExpr > const &	mat_exp,
		Scalar const &	scalar
	)

inlinenoexcept

Returns a scalar, dense matrix product expression.

Parameters

lhs	the left-hand side dense matrix
rhs	the right-hand side scalar variable

◆ mult() [7/10]

template<typename ScalExpr , typename DVecExpr >

auto mgcpp::mult	(	scalar_expr< ScalExpr > const &	scalar,
		dvec_expr< DVecExpr > const &	vec_exp
	)

inlinenoexcept

Returns a scalar, dense vector product expression.

Parameters

lhs	the left-hand side scalar expression
rhs	the right-hand side dense vector

◆ mult() [8/10]

template<typename ScalExpr , typename DMatExpr >

auto mgcpp::mult	(	scalar_expr< ScalExpr > const &	scalar,
		dmat_expr< DMatExpr > const &	mat_exp
	)

inlinenoexcept

Returns a scalar, dense matrix product expression.

Parameters

lhs	the left-hand side scalar expression
rhs	the right-hand side dense matrix

◆ mult() [9/10]

template<typename ScalExpr , typename DVecExpr >

auto mgcpp::mult	(	dvec_expr< DVecExpr > const &	vec_exp,
		scalar_expr< ScalExpr > const &	scalar
	)

inlinenoexcept

Returns a scalar, dense vector product expression.

Parameters

lhs	the left-hand side dense vector
rhs	the right-hand side expression

◆ mult() [10/10]

template<typename ScalExpr , typename DMatExpr >

auto mgcpp::mult	(	dmat_expr< DMatExpr > const &	mat_exp,
		scalar_expr< ScalExpr > const &	scalar
	)

inlinenoexcept

Returns a scalar, dense matrix product expression.

Parameters

lhs	the left-hand side dense matrix
rhs	the right-hand side expression

◆ operator!=() [1/2]

bool mgcpp::operator!=	(	const memory_resource &	a,
		const memory_resource &	b
	)

inline

◆ operator!=() [2/2]

template<typename T1 , typename T2 >

bool mgcpp::operator!=	(	allocator< T1 > const &	a,
		allocator< T2 > const &	b
	)

◆ operator*() [1/10]

template<typename LhsExpr , typename RhsExpr >

dmat_dmat_mult_expr<LhsExpr, RhsExpr> mgcpp::operator*	(	dmat_expr< LhsExpr > const &	lhs,
		dmat_expr< RhsExpr > const &	rhs
	)

inlinenoexcept

Returns a dense matrix product expression.

Parameters

lhs	the left-hand side dense matrix
rhs	the right-hand side dense matrix

◆ operator*() [2/10]

template<typename MatExpr , typename VecExpr >

dmat_dvec_mult_expr<MatExpr, VecExpr> mgcpp::operator*	(	dmat_expr< MatExpr > const &	mat,
		dvec_expr< VecExpr > const &	vec
	)

inlinenoexcept

Returns a dense matrix vector product expression.

Parameters

lhs	the left-hand side dense matrix
rhs	the right-hand side dense vector

◆ operator*() [3/10]

template<typename Scalar , typename DVecExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>

auto mgcpp::operator*	(	Scalar const &	scalar,
		dvec_expr< DVecExpr > const &	exp
	)

inlinenoexcept

Returns a scalar, dense vector product expression.

Parameters

lhs	the left-hand side scalar variable
rhs	the right-hand side dense vector

◆ operator*() [4/10]

template<typename Scalar , typename DMatExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>

auto mgcpp::operator*	(	Scalar const &	scalar,
		dmat_expr< DMatExpr > const &	exp
	)

inlinenoexcept

Returns a scalar, dense matrix product expression.

Parameters

lhs	the left-hand side scalar variable
rhs	the right-hand side dense matrix

◆ operator*() [5/10]

template<typename Scalar , typename DVecExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>

auto mgcpp::operator*	(	dvec_expr< DVecExpr > const &	exp,
		Scalar const &	scalar
	)

inlinenoexcept

Returns a scalar, dense vector product expression.

Parameters

lhs	the left-hand side dense vector
rhs	the right-hand side scalar variable

◆ operator*() [6/10]

template<typename Scalar , typename DMatExpr , typename = typename std::enable_if<is_scalar<Scalar>::value>::type>

auto mgcpp::operator*	(	dmat_expr< DMatExpr > const &	exp,
		Scalar const &	scalar
	)

inlinenoexcept

Returns a scalar, dense matrix product expression.

Parameters

lhs	the left-hand side dense matrix
rhs	the right-hand side scalar variable

◆ operator*() [7/10]

template<typename ScalExpr , typename DVecExpr >

auto mgcpp::operator*	(	scalar_expr< ScalExpr > const &	scalar,
		dvec_expr< DVecExpr > const &	exp
	)

inlinenoexcept

Returns a scalar, dense vector product expression.

Parameters

lhs	the left-hand side scalar expression
rhs	the right-hand side dense vector

◆ operator*() [8/10]

template<typename ScalExpr , typename DMatExpr >

auto mgcpp::operator*	(	scalar_expr< ScalExpr > const &	scalar,
		dmat_expr< DMatExpr > const &	exp
	)

inlinenoexcept

Returns a scalar, dense matrix product expression.

Parameters

lhs	the left-hand side scalar expression
rhs	the right-hand side dense matrix

◆ operator*() [9/10]

template<typename ScalExpr , typename DVecExpr >

auto mgcpp::operator*	(	dvec_expr< DVecExpr > const &	exp,
		scalar_expr< ScalExpr > const &	scalar
	)

inlinenoexcept

Returns a scalar, dense vector product expression.

Parameters

lhs	the left-hand side dense vector
rhs	the right-hand side scalar expression

◆ operator*() [10/10]

template<typename ScalExpr , typename DMatExpr >

auto mgcpp::operator*	(	dmat_expr< DMatExpr > const &	exp,
		scalar_expr< ScalExpr > const &	scalar
	)

inlinenoexcept

Returns a scalar, dense matrix product expression.

Parameters

lhs	the left-hand side dense matrix
rhs	the right-hand side scalar expression

◆ operator+() [1/2]

template<typename LhsExpr , typename RhsExpr >

auto mgcpp::operator+	(	dmat_expr< LhsExpr > const &	lhs,
		dmat_expr< RhsExpr > const &	rhs
	)

inlinenoexcept

◆ operator+() [2/2]

template<typename LhsExpr , typename RhsExpr >

dvec_dvec_add_expr<LhsExpr, RhsExpr> mgcpp::operator+	(	dvec_expr< LhsExpr > const &	lhs,
		dvec_expr< RhsExpr > const &	rhs
	)

inlinenoexcept

Returns a dense vector addition expression.

Parameters

lhs	the left-hand side dense vector
rhs	the right-hand side dense vector

◆ operator-()

template<typename LhsExpr , typename RhsExpr >

auto mgcpp::operator-	(	dmat_expr< LhsExpr > const &	lhs,
		dmat_expr< RhsExpr > const &	rhs
	)

inlinenoexcept

◆ operator<<()

template<typename Expr >

std::ostream& mgcpp::operator<<	(	std::ostream &	os,
		expression< Expr > const &	expr
	)

◆ operator==() [1/2]

bool mgcpp::operator==	(	const memory_resource &	a,
		const memory_resource &	b
	)

inline

◆ operator==() [2/2]

template<typename T1 , typename T2 >

bool mgcpp::operator==	(	allocator< T1 > const &	a,
		allocator< T2 > const &	b
	)

◆ outer()

template<typename LhsExpr , typename RhsExpr >

auto mgcpp::outer	(	dvec_expr< LhsExpr > const &	lhs,
		dvec_expr< RhsExpr > const &	rhs
	)

noexcept

◆ pun_cast() [1/2]

template<typename To , typename From >

To mgcpp::pun_cast ( From const * from )

inline

◆ pun_cast() [2/2]

template<typename To , typename From >

To mgcpp::pun_cast ( From * from )

inline

◆ reduce_mean() [1/2]

template<typename Expr >

decltype(auto) mgcpp::reduce_mean ( dmat_expr< Expr > const & expr )

inlinenoexcept

◆ reduce_mean() [2/2]

template<typename Expr >

decltype(auto) mgcpp::reduce_mean ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ reduce_sum() [1/2]

template<typename Expr >

decltype(auto) mgcpp::reduce_sum ( dmat_expr< Expr > const & expr )

inlinenoexcept

◆ reduce_sum() [2/2]

template<typename Expr >

decltype(auto) mgcpp::reduce_sum ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ ref() [1/2]

template<typename DenseVector , typename Type >

dvec_ref_expr<DenseVector> mgcpp::ref ( dense_vector< DenseVector, Type > const & mat )

inline

◆ ref() [2/2]

template<typename DenseMatrix , typename Type >

dmat_ref_expr<DenseMatrix> mgcpp::ref ( dense_matrix< DenseMatrix, Type > const & mat )

inline

◆ relu()

template<typename Expr >

decltype(auto) mgcpp::relu ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ scal()

template<typename Type >

scalar_constant_expr<Type> mgcpp::scal ( Type scalar )

inline

◆ sin()

template<typename Expr >

decltype(auto) mgcpp::sin ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ sinh()

template<typename Expr >

decltype(auto) mgcpp::sinh ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ sub()

template<typename LhsExpr , typename RhsExpr >

auto mgcpp::sub	(	dmat_expr< LhsExpr > const &	lhs,
		dmat_expr< RhsExpr > const &	rhs
	)

inlinenoexcept

◆ sum_tuple()

template<class Tuple >

decltype(auto) constexpr mgcpp::sum_tuple ( Tuple && t )

◆ sym_shape()

template<typename Expr >

symbolic_shape_expr<Expr> mgcpp::sym_shape ( Expr const & expr )

inline

◆ take_front()

template<size_t N, class Tuple >

decltype(auto) constexpr mgcpp::take_front ( Tuple && t )

◆ take_rest()

template<size_t N, class Tuple >

decltype(auto) constexpr mgcpp::take_rest ( Tuple && t )

◆ tan()

template<typename Expr >

decltype(auto) mgcpp::tan ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ tanh()

template<typename Expr >

decltype(auto) mgcpp::tanh ( dvec_expr< Expr > const & expr )

inlinenoexcept

◆ tie()

template<typename... Exprs>

tie_op<Exprs...> mgcpp::tie ( Exprs const &... exprs )

inline

◆ trans()

template<typename Expr >

dmat_trans_expr<Expr> mgcpp::trans ( dmat_expr< Expr > const & expr )

inlinenoexcept

◆ zip()

template<class Tuple1 , class Tuple2 >

decltype(auto) constexpr mgcpp::zip	(	Tuple1 &&	t1,
		Tuple2 &&	t2
	)

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ binary_expr

◆ complex

◆ cublas_error_t

◆ cuda_error_t

◆ cufft_error_t

◆ dmat_dmat_add_expr

◆ dmat_dmat_mult_expr

◆ dmat_dvec_mult_expr

◆ dmat_reduce_mean_expr

◆ dmat_reduce_sum_expr

◆ dmat_ref_expr

◆ dmat_trans_expr

◆ dvec_dvec_add_expr

◆ dvec_dvec_outer_expr

◆ dvec_map_expr

◆ dvec_reduce_mean_expr

◆ dvec_reduce_sum_expr

◆ dvec_ref_expr

◆ free_mem_t

◆ hash_table

◆ ones_mat_expr

◆ ones_vec_expr

◆ pad_size_t

◆ placeholder_node

◆ scalar_constant_expr

◆ scalar_dmat_mult_expr

◆ scalar_dvec_mult_expr

◆ scalar_one_constant_expr

◆ scalar_zero_constant_expr

◆ symbolic_shape_expr

◆ tie_op

◆ total_mem_t

◆ unary_expr

◆ void_t

◆ zeros_mat_expr

◆ zeros_vec_expr

Enumeration Type Documentation

◆ byte

◆ cuda_memcpy_kind

◆ fft_direction

◆ mgblas_error_t

◆ status_t

Function Documentation

◆ abs()

◆ add() [1/2]

◆ add() [2/2]

◆ analyze_graph()

◆ apply()

◆ apply_void()

◆ ASSERT_MESSAGE()

◆ cos()

◆ cosh()

◆ cuda_free()

◆ cuda_malloc()

◆ cuda_mem_get_info()

◆ cuda_memcpy() [1/5]

◆ cuda_memcpy() [2/5]

◆ cuda_memcpy() [3/5]

◆ cuda_memcpy() [4/5]

◆ cuda_memcpy() [5/5]

◆ cuda_memset_to_zero()

◆ cuda_set_device()

◆ enumerate()

◆ eval() [1/2]

◆ eval() [2/2]

◆ evaluate_if_needed()

◆ free_pinned()

◆ get_last_run_cache_hits()

◆ grad()

◆ init()

◆ make_error_code()

◆ make_error_condition()

◆ make_id()

◆ make_ones_like() [1/2]