Namespaces
namespace	hidden

Classes
struct	tuple_size< const std::variant< Ts... > & >

struct	tuple_size< const std::variant< Ts... > && >

struct	tuple_size< const std::variant< Ts... > >

struct	tuple_size< const T(&&)[N] >

struct	tuple_size< const T(&)[N] >

struct	tuple_size< const T[N] >

struct	tuple_size< std::variant< Ts... > & >

struct	tuple_size< std::variant< Ts... > && >

struct	tuple_size< std::variant< Ts... > >

struct	tuple_size< T(&&)[N] >

struct	tuple_size< T(&)[N] >

struct	tuple_size< T[N] >

Functions
template<typename OperationType , typename... ArgTypes>
auto	apply_operation (OperationType &&operation, const std::tuple< ArgTypes... > &tuple)

template<typename OperationType , typename T , size_t Size>
auto	apply_operation (OperationType &&operation, const std::array< T, Size > &array)

template<typename OperationType , typename T , size_t Size>
void	apply_operation_inplace (OperationType &&operation, std::array< T, Size > &array)

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>
auto	operator== (const std::array< T, Size1 > &array_a, const std::array< T, Size2 > &array_b)

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>
auto	operator!= (const std::array< T, Size1 > &array_a, const std::array< T, Size2 > &array_b)

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>
auto	operator== (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>
auto	operator!= (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>
auto	operator< (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>
auto	operator<= (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>
auto	operator> (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>
auto	operator>= (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>
auto	operator< (const std::array< T, Size1 > &array_a, const std::array< T, Size2 > &array_b)

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>
auto	operator<= (const std::array< T, Size1 > &array_a, const std::array< T, Size2 > &array_b)

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>
auto	operator> (const std::array< T, Size1 > &array_a, const std::array< T, Size2 > &array_b)

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>
auto	operator>= (const std::array< T, Size1 > &array_a, const std::array< T, Size2 > &array_b)

template<typename T , typename S >
auto	fail_safe_addition (T &&a, T &&b)

template<typename T , typename S >
auto	fail_safe_subtraction (T &&a, T &&b)

template<typename T , typename S >
auto	fail_safe_multiplication (T &&a, T &&b)

template<typename... ArgTypes1, typename... ArgTypes2, typename common_type = types::tuple_operation_valid_t<std::tuple<ArgTypes1...>, std::tuple<ArgTypes2...>>, typename = std::enable_if_t<!std::is_same_v<common_type, std::tuple<>>>>
auto	operator+ (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b)

template<typename... ArgTypes1, typename... ArgTypes2, typename common_type = types::tuple_operation_valid_t<std::tuple<ArgTypes1...>, std::tuple<ArgTypes2...>>, typename = std::enable_if_t<!std::is_same_v<common_type, std::tuple<>>>>
auto	operator- (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b)

template<typename... ArgTypes1, typename... ArgTypes2, typename common_type = types::tuple_operation_valid_t<std::tuple<ArgTypes1...>, std::tuple<ArgTypes2...>>, typename = std::enable_if_t<!std::is_same_v<common_type, std::tuple<>>>>
auto	operator* (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b)

template<typename... ArgTypes1, typename... ArgTypes2, typename common_type = types::tuple_operation_valid_t<std::tuple<ArgTypes1...>, std::tuple<ArgTypes2...>>, typename = std::enable_if_t<!std::is_same_v<common_type, std::tuple<>>>>
auto	operator/ (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b)

template<typename T , typename S >
auto	fail_safe_addition (T &&a, S &&b)

template<typename T , typename S >
auto	fail_safe_subtraction (T &&a, S &&b)

template<typename T , typename S >
auto	fail_safe_multiplication (T &&a, S &&b)

template<typename T , typename S >
auto	fail_safe_division (T &&a, S &&b)

template<typename T , typename... ArgTypes>
auto	operator+ (const T &scalar, const std::tuple< ArgTypes... > &tuple)

template<typename T , typename... ArgTypes>
auto	operator+ (const std::tuple< ArgTypes... > &tuple, const T &scalar)

template<typename T , typename... ArgTypes>
auto	operator- (const T &scalar, const std::tuple< ArgTypes... > &tuple)

template<typename T , typename... ArgTypes>
auto	operator- (const std::tuple< ArgTypes... > &tuple, const T &scalar)

template<typename T , typename... ArgTypes>
auto	operator* (const T &scalar, const std::tuple< ArgTypes... > &tuple)

template<typename T , typename... ArgTypes>
auto	operator* (const std::tuple< ArgTypes... > &tuple, const T &scalar)

template<typename T , typename... ArgTypes>
auto	operator/ (const T &scalar, const std::tuple< ArgTypes... > &tuple)

template<typename T , typename... ArgTypes>
auto	operator/ (const std::tuple< ArgTypes... > &tuple, const T &scalar)

template<typename OperationType , typename... ArgTypes>
void	apply_operation_inplace (OperationType &&operation, std::tuple< ArgTypes... > &tuple)

template<typename T , typename S , size_t Size>
auto	operator+ (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size>
auto	operator- (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size>
auto	operator* (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size>
auto	operator/ (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b)

template<typename T , typename S , size_t Size>
auto	operator+ (const T &scalar, const std::array< S, Size > &array)

template<typename T , typename S , size_t Size>
auto	operator+ (const std::array< S, Size > &array, const T &scalar)

template<typename T , typename S , size_t Size>
auto	operator- (const T &scalar, const std::array< S, Size > &array)

template<typename T , typename S , size_t Size>
auto	operator- (const std::array< S, Size > &array, const T &scalar)

template<typename T , typename S , size_t Size>
auto	operator* (const T &scalar, const std::array< S, Size > &array)

template<typename T , typename S , size_t Size>
auto	operator* (const std::array< S, Size > &array, const T &scalar)

template<typename T , typename S , size_t Size>
auto	operator/ (const T &scalar, const std::array< S, Size > &array)

template<typename T , typename S , size_t Size>
auto	operator/ (const std::array< S, Size > &array, const T &scalar)

template<typename... Elements, typename commom_element_type = types::tuple_common_element_t<std::tuple<Elements...>>>
auto	sum_of_elements (const std::tuple< Elements... > &tuple)

template<typename... Elements, typename commom_element_type = types::tuple_common_element_t<std::tuple<Elements...>>>
double	mean_of_elements (const std::tuple< Elements... > &tuple)

template<typename... Elements, typename commom_element_type = types::tuple_common_element_t<std::tuple<Elements...>>>
double	standard_deviation (const std::tuple< Elements... > &tuple)

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > >	operator+ (const std::variant< EleTypes... > &variant_a, const std::variant< EleTypes... > &variant_b)

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > >	operator- (const std::variant< EleTypes... > &variant_a, const std::variant< EleTypes... > &variant_b)

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > >	operator* (const std::variant< EleTypes... > &variant_a, const std::variant< EleTypes... > &variant_b)

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > >	operator/ (const std::variant< EleTypes... > &variant_a, const std::variant< EleTypes... > &variant_b)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator+ (const T &v, const std::variant< EleTypes... > &variant)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator+ (const std::variant< EleTypes... > &variant, const T &v)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator- (const T &v, const std::variant< EleTypes... > &variant)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator- (const std::variant< EleTypes... > &variant, const T &v)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator* (const T &v, const std::variant< EleTypes... > &variant)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator* (const std::variant< EleTypes... > &variant, const T &v)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator/ (const T &v, const std::variant< EleTypes... > &variant)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator/ (const std::variant< EleTypes... > &variant, const T &v)

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > >	operator+ (const std::variant< EleTypes... > &variant_a, const std::variant< EleTypes... > &variant_b)

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > >	operator- (const std::variant< EleTypes... > &variant_a, const std::variant< EleTypes... > &variant_b)

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > >	operator* (const std::variant< EleTypes... > &variant_a, const std::variant< EleTypes... > &variant_b)

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > >	operator/ (const std::variant< EleTypes... > &variant_a, const std::variant< EleTypes... > &variant_b)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator+ (const T &v, const std::variant< EleTypes... > &variant)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator+ (const std::variant< EleTypes... > &variant, const T &v)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator- (const T &v, const std::variant< EleTypes... > &variant)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator- (const std::variant< EleTypes... > &variant, const T &v)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator* (const T &v, const std::variant< EleTypes... > &variant)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator* (const std::variant< EleTypes... > &variant, const T &v)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator/ (const T &v, const std::variant< EleTypes... > &variant)

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>
std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > &&types::is_type_in_list_v< T, list >, std::variant< EleTypes... > >	operator/ (const std::variant< EleTypes... > &variant, const T &v)

template<auto N1, auto D1, auto N2, auto D2>
constexpr auto	operator* (std::ratio< N1, D1 >, std::ratio< N2, D2 >)

template<auto N1, auto D1, auto N2, auto D2>
constexpr auto	operator/ (std::ratio< N1, D1 > a, std::ratio< N2, D2 >)

template<auto N1, auto D1, auto N2, auto D2>
constexpr auto	operator+ (std::ratio< N1, D1 >, std::ratio< N2, D2 >)

template<auto N1, auto D1, auto N2, auto D2>
constexpr auto	operator- (std::ratio< N1, D1 >, std::ratio< N2, D2 >)

Function Documentation

◆ apply_operation() [1/2]

template<typename OperationType , typename T , size_t Size>

auto std::apply_operation	(	OperationType &&	operation,
		const std::array< T, Size > &	array
	)

Definition at line 751 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ apply_operation() [2/2]

template<typename OperationType , typename... ArgTypes>

auto std::apply_operation	(	OperationType &&	operation,
		const std::tuple< ArgTypes... > &	tuple
	)

Definition at line 569 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_operation_inplace() [1/2]

template<typename OperationType , typename T , size_t Size>

void std::apply_operation_inplace	(	OperationType &&	operation,
		std::array< T, Size > &	array
	)

Definition at line 757 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_operation_inplace() [2/2]

template<typename OperationType , typename... ArgTypes>

void std::apply_operation_inplace	(	OperationType &&	operation,
		std::tuple< ArgTypes... > &	tuple
	)

Definition at line 577 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ fail_safe_addition() [1/2]

template<typename T , typename S >

auto std::fail_safe_addition	(	T &&	a,
		S &&	b
	)

inline

Definition at line 121 of file tpf_std_extensions.hpp.

◆ fail_safe_addition() [2/2]

template<typename T , typename S >

auto std::fail_safe_addition	(	T &&	a,
		T &&	b
	)

Here is the caller graph for this function:

◆ fail_safe_division()

template<typename T , typename S >

auto std::fail_safe_division	(	T &&	a,
		S &&	b
	)

inline

Definition at line 169 of file tpf_std_extensions.hpp.

Here is the caller graph for this function:

◆ fail_safe_multiplication() [1/2]

template<typename T , typename S >

auto std::fail_safe_multiplication	(	T &&	a,
		S &&	b
	)

inline

Definition at line 153 of file tpf_std_extensions.hpp.

◆ fail_safe_multiplication() [2/2]

template<typename T , typename S >

auto std::fail_safe_multiplication	(	T &&	a,
		T &&	b
	)

Here is the caller graph for this function:

◆ fail_safe_subtraction() [1/2]

template<typename T , typename S >

auto std::fail_safe_subtraction	(	T &&	a,
		S &&	b
	)

inline

Definition at line 137 of file tpf_std_extensions.hpp.

◆ fail_safe_subtraction() [2/2]

template<typename T , typename S >

auto std::fail_safe_subtraction	(	T &&	a,
		T &&	b
	)

Here is the caller graph for this function:

◆ mean_of_elements()

template<typename... Elements, typename commom_element_type = types::tuple_common_element_t<std::tuple<Elements...>>>

double std::mean_of_elements ( const std::tuple< Elements... > & tuple )

Definition at line 782 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator!=() [1/2]

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>

auto std::operator!=	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 644 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator!=() [2/2]

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>

auto std::operator!=	(	const std::array< T, Size1 > &	array_a,
		const std::array< T, Size2 > &	array_b
	)

Definition at line 608 of file tpf_std_extensions.hpp.

◆ operator*() [1/13]

template<typename T , typename S , size_t Size>

auto std::operator*	(	const std::array< S, Size > &	array,
		const T &	scalar
	)

Definition at line 733 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator*() [2/13]

template<typename T , typename S , size_t Size>

auto std::operator*	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 688 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator*() [3/13]

template<typename T , typename... ArgTypes>

auto std::operator*	(	const std::tuple< ArgTypes... > &	tuple,
		const T &	scalar
	)

Definition at line 547 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator*() [4/13]

template<typename... ArgTypes1, typename... ArgTypes2, typename common_type = types::tuple_operation_valid_t<std::tuple<ArgTypes1...>, std::tuple<ArgTypes2...>>, typename = std::enable_if_t<!std::is_same_v<common_type, std::tuple<>>>>

auto std::operator*	(	const std::tuple< ArgTypes1... > &	tuple_a,
		const std::tuple< ArgTypes2... > &	tuple_b
	)

Definition at line 497 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator*() [5/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator*	(	const std::variant< EleTypes... > &	variant,
		const T &	v
	)

Definition at line 1116 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator*() [6/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator*	(	const std::variant< EleTypes... > &	variant,
		const T &	v
	)

Definition at line 1595 of file tpf_std_extensions.hpp.

◆ operator*() [7/13]

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > > std::operator*	(	const std::variant< EleTypes... > &	variant_a,
		const std::variant< EleTypes... > &	variant_b
	)

Definition at line 895 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator*() [8/13]

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > > std::operator*	(	const std::variant< EleTypes... > &	variant_a,
		const std::variant< EleTypes... > &	variant_b
	)

Definition at line 1303 of file tpf_std_extensions.hpp.

◆ operator*() [9/13]

template<typename T , typename S , size_t Size>

auto std::operator*	(	const T &	scalar,
		const std::array< S, Size > &	array
	)

Definition at line 727 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator*() [10/13]

template<typename T , typename... ArgTypes>

auto std::operator*	(	const T &	scalar,
		const std::tuple< ArgTypes... > &	tuple
	)

Definition at line 540 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator*() [11/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator*	(	const T &	v,
		const std::variant< EleTypes... > &	variant
	)

Definition at line 1087 of file tpf_std_extensions.hpp.

◆ operator*() [12/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator*	(	const T &	v,
		const std::variant< EleTypes... > &	variant
	)

Definition at line 1556 of file tpf_std_extensions.hpp.

◆ operator*() [13/13]

template<auto N1, auto D1, auto N2, auto D2>

constexpr auto std::operator*	(	std::ratio< N1, D1 >	,
		std::ratio< N2, D2 >
	)

constexpr

Definition at line 1710 of file tpf_std_extensions.hpp.

◆ operator+() [1/13]

template<typename T , typename S , size_t Size>

auto std::operator+	(	const std::array< S, Size > &	array,
		const T &	scalar
	)

Definition at line 709 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [2/13]

template<typename T , typename S , size_t Size>

auto std::operator+	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 674 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [3/13]

template<typename T , typename... ArgTypes>

auto std::operator+	(	const std::tuple< ArgTypes... > &	tuple,
		const T &	scalar
	)

Definition at line 519 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [4/13]

template<typename... ArgTypes1, typename... ArgTypes2, typename common_type = types::tuple_operation_valid_t<std::tuple<ArgTypes1...>, std::tuple<ArgTypes2...>>, typename = std::enable_if_t<!std::is_same_v<common_type, std::tuple<>>>>

auto std::operator+	(	const std::tuple< ArgTypes1... > &	tuple_a,
		const std::tuple< ArgTypes2... > &	tuple_b
	)

Definition at line 483 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [5/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator+	(	const std::variant< EleTypes... > &	variant,
		const T &	v
	)

Definition at line 1000 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [6/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator+	(	const std::variant< EleTypes... > &	variant,
		const T &	v
	)

Definition at line 1441 of file tpf_std_extensions.hpp.

◆ operator+() [7/13]

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > > std::operator+	(	const std::variant< EleTypes... > &	variant_a,
		const std::variant< EleTypes... > &	variant_b
	)

Definition at line 819 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [8/13]

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > > std::operator+	(	const std::variant< EleTypes... > &	variant_a,
		const std::variant< EleTypes... > &	variant_b
	)

Definition at line 1205 of file tpf_std_extensions.hpp.

◆ operator+() [9/13]

template<typename T , typename S , size_t Size>

auto std::operator+	(	const T &	scalar,
		const std::array< S, Size > &	array
	)

Definition at line 703 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [10/13]

template<typename T , typename... ArgTypes>

auto std::operator+	(	const T &	scalar,
		const std::tuple< ArgTypes... > &	tuple
	)

Definition at line 512 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [11/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator+	(	const T &	v,
		const std::variant< EleTypes... > &	variant
	)

Definition at line 971 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator+() [12/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator+	(	const T &	v,
		const std::variant< EleTypes... > &	variant
	)

Definition at line 1402 of file tpf_std_extensions.hpp.

◆ operator+() [13/13]

template<auto N1, auto D1, auto N2, auto D2>

constexpr auto std::operator+	(	std::ratio< N1, D1 >	,
		std::ratio< N2, D2 >
	)

constexpr

Definition at line 1733 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [1/13]

template<typename T , typename S , size_t Size>

auto std::operator-	(	const std::array< S, Size > &	array,
		const T &	scalar
	)

Definition at line 721 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [2/13]

template<typename T , typename S , size_t Size>

auto std::operator-	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 681 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [3/13]

template<typename T , typename... ArgTypes>

auto std::operator-	(	const std::tuple< ArgTypes... > &	tuple,
		const T &	scalar
	)

Definition at line 533 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [4/13]

template<typename... ArgTypes1, typename... ArgTypes2, typename common_type = types::tuple_operation_valid_t<std::tuple<ArgTypes1...>, std::tuple<ArgTypes2...>>, typename = std::enable_if_t<!std::is_same_v<common_type, std::tuple<>>>>

auto std::operator-	(	const std::tuple< ArgTypes1... > &	tuple_a,
		const std::tuple< ArgTypes2... > &	tuple_b
	)

Definition at line 490 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [5/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator-	(	const std::variant< EleTypes... > &	variant,
		const T &	v
	)

Definition at line 1058 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [6/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator-	(	const std::variant< EleTypes... > &	variant,
		const T &	v
	)

Definition at line 1517 of file tpf_std_extensions.hpp.

◆ operator-() [7/13]

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > > std::operator-	(	const std::variant< EleTypes... > &	variant_a,
		const std::variant< EleTypes... > &	variant_b
	)

Definition at line 857 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [8/13]

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > > std::operator-	(	const std::variant< EleTypes... > &	variant_a,
		const std::variant< EleTypes... > &	variant_b
	)

Definition at line 1254 of file tpf_std_extensions.hpp.

◆ operator-() [9/13]

template<typename T , typename S , size_t Size>

auto std::operator-	(	const T &	scalar,
		const std::array< S, Size > &	array
	)

Definition at line 715 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [10/13]

template<typename T , typename... ArgTypes>

auto std::operator-	(	const T &	scalar,
		const std::tuple< ArgTypes... > &	tuple
	)

Definition at line 526 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [11/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator-	(	const T &	v,
		const std::variant< EleTypes... > &	variant
	)

Definition at line 1029 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator-() [12/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator-	(	const T &	v,
		const std::variant< EleTypes... > &	variant
	)

Definition at line 1478 of file tpf_std_extensions.hpp.

◆ operator-() [13/13]

template<auto N1, auto D1, auto N2, auto D2>

constexpr auto std::operator-	(	std::ratio< N1, D1 >	,
		std::ratio< N2, D2 >
	)

constexpr

Definition at line 1752 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [1/13]

template<typename T , typename S , size_t Size>

auto std::operator/	(	const std::array< S, Size > &	array,
		const T &	scalar
	)

Definition at line 745 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [2/13]

template<typename T , typename S , size_t Size>

auto std::operator/	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 695 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [3/13]

template<typename T , typename... ArgTypes>

auto std::operator/	(	const std::tuple< ArgTypes... > &	tuple,
		const T &	scalar
	)

Definition at line 561 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [4/13]

template<typename... ArgTypes1, typename... ArgTypes2, typename common_type = types::tuple_operation_valid_t<std::tuple<ArgTypes1...>, std::tuple<ArgTypes2...>>, typename = std::enable_if_t<!std::is_same_v<common_type, std::tuple<>>>>

auto std::operator/	(	const std::tuple< ArgTypes1... > &	tuple_a,
		const std::tuple< ArgTypes2... > &	tuple_b
	)

Definition at line 504 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [5/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator/	(	const std::variant< EleTypes... > &	variant,
		const T &	v
	)

Definition at line 1174 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [6/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator/	(	const std::variant< EleTypes... > &	variant,
		const T &	v
	)

Definition at line 1673 of file tpf_std_extensions.hpp.

◆ operator/() [7/13]

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > > std::operator/	(	const std::variant< EleTypes... > &	variant_a,
		const std::variant< EleTypes... > &	variant_b
	)

Definition at line 933 of file tpf_std_extensions.hpp.

◆ operator/() [8/13]

template<typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list >, std::variant< EleTypes... > > std::operator/	(	const std::variant< EleTypes... > &	variant_a,
		const std::variant< EleTypes... > &	variant_b
	)

Definition at line 1352 of file tpf_std_extensions.hpp.

◆ operator/() [9/13]

template<typename T , typename S , size_t Size>

auto std::operator/	(	const T &	scalar,
		const std::array< S, Size > &	array
	)

Definition at line 739 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [10/13]

template<typename T , typename... ArgTypes>

auto std::operator/	(	const T &	scalar,
		const std::tuple< ArgTypes... > &	tuple
	)

Definition at line 554 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [11/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t< types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator/	(	const T &	v,
		const std::variant< EleTypes... > &	variant
	)

Definition at line 1145 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator/() [12/13]

template<typename T , typename ... EleTypes, typename list = types::type_list_t<EleTypes...>>

std::enable_if_t<!types::is_type_in_list_v< types::no_throw_t, list > && types::is_type_in_list_v< T, list >, std::variant< EleTypes... > > std::operator/	(	const T &	v,
		const std::variant< EleTypes... > &	variant
	)

Definition at line 1634 of file tpf_std_extensions.hpp.

◆ operator/() [13/13]

template<auto N1, auto D1, auto N2, auto D2>

constexpr auto std::operator/	(	std::ratio< N1, D1 >	a,
		std::ratio< N2, D2 >
	)

constexpr

Definition at line 1725 of file tpf_std_extensions.hpp.

◆ operator<() [1/2]

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>

auto std::operator<	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 650 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator<() [2/2]

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>

auto std::operator<	(	const std::array< T, Size1 > &	array_a,
		const std::array< T, Size2 > &	array_b
	)

Definition at line 614 of file tpf_std_extensions.hpp.

◆ operator<=() [1/2]

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>

auto std::operator<=	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 656 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator<=() [2/2]

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>

auto std::operator<=	(	const std::array< T, Size1 > &	array_a,
		const std::array< T, Size2 > &	array_b
	)

Definition at line 620 of file tpf_std_extensions.hpp.

◆ operator==() [1/2]

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>

auto std::operator==	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 638 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator==() [2/2]

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>

auto std::operator==	(	const std::array< T, Size1 > &	array_a,
		const std::array< T, Size2 > &	array_b
	)

Definition at line 602 of file tpf_std_extensions.hpp.

◆ operator>() [1/2]

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>

auto std::operator>	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 662 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator>() [2/2]

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>

auto std::operator>	(	const std::array< T, Size1 > &	array_a,
		const std::array< T, Size2 > &	array_b
	)

Definition at line 626 of file tpf_std_extensions.hpp.

◆ operator>=() [1/2]

template<typename T , typename S , size_t Size, typename = std::enable_if_t<!std::is_same_v<T, S>>>

auto std::operator>=	(	const std::array< T, Size > &	array_a,
		const std::array< S, Size > &	array_b
	)

Definition at line 668 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ operator>=() [2/2]

template<typename T , size_t Size1, size_t Size2, typename = std::enable_if_t<Size1 != Size2>>

auto std::operator>=	(	const std::array< T, Size1 > &	array_a,
		const std::array< T, Size2 > &	array_b
	)

Definition at line 632 of file tpf_std_extensions.hpp.

◆ standard_deviation()

template<typename... Elements, typename commom_element_type = types::tuple_common_element_t<std::tuple<Elements...>>>

double std::standard_deviation ( const std::tuple< Elements... > & tuple )

Definition at line 792 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

◆ sum_of_elements()

template<typename... Elements, typename commom_element_type = types::tuple_common_element_t<std::tuple<Elements...>>>

auto std::sum_of_elements ( const std::tuple< Elements... > & tuple )

Definition at line 764 of file tpf_std_extensions.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

Namespaces

Classes

Functions

Function Documentation

◆ apply_operation() [1/2]

◆ apply_operation() [2/2]

◆ apply_operation_inplace() [1/2]

◆ apply_operation_inplace() [2/2]

◆ fail_safe_addition() [1/2]

◆ fail_safe_addition() [2/2]

◆ fail_safe_division()

◆ fail_safe_multiplication() [1/2]

◆ fail_safe_multiplication() [2/2]

◆ fail_safe_subtraction() [1/2]

◆ fail_safe_subtraction() [2/2]

◆ mean_of_elements()

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ operator*() [1/13]

◆ operator*() [2/13]

◆ operator*() [3/13]

◆ operator*() [4/13]

◆ operator*() [5/13]

◆ operator*() [6/13]

◆ operator*() [7/13]

◆ operator*() [8/13]

◆ operator*() [9/13]

◆ operator*() [10/13]

◆ operator*() [11/13]

◆ operator*() [12/13]

◆ operator*() [13/13]

◆ operator+() [1/13]

◆ operator+() [2/13]

◆ operator+() [3/13]

◆ operator+() [4/13]

◆ operator+() [5/13]

◆ operator+() [6/13]

◆ operator+() [7/13]

◆ operator+() [8/13]

◆ operator+() [9/13]

◆ operator+() [10/13]

◆ operator+() [11/13]

◆ operator+() [12/13]

◆ operator+() [13/13]

◆ operator-() [1/13]

◆ operator-() [2/13]

◆ operator-() [3/13]

◆ operator-() [4/13]

◆ operator-() [5/13]

◆ operator-() [6/13]

◆ operator-() [7/13]

◆ operator-() [8/13]

◆ operator-() [9/13]

◆ operator-() [10/13]

◆ operator-() [11/13]

◆ operator-() [12/13]

◆ operator-() [13/13]

◆ operator/() [1/13]

◆ operator/() [2/13]

◆ operator/() [3/13]

◆ operator/() [4/13]

◆ operator/() [5/13]

◆ operator/() [6/13]

◆ operator/() [7/13]

◆ operator/() [8/13]

◆ operator/() [9/13]

◆ operator/() [10/13]

◆ operator/() [11/13]

◆ operator/() [12/13]

◆ operator/() [13/13]

◆ operator<() [1/2]

◆ operator<() [2/2]

◆ operator<=() [1/2]

◆ operator<=() [2/2]

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ operator>() [1/2]

◆ operator>() [2/2]

◆ operator>=() [1/2]

◆ operator>=() [2/2]