tpf_std_extensions.hpp File Reference

Type functions are implemented. More...

#include <tpf_types.hpp>
#include <cmath>

Include dependency graph for tpf_std_extensions.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
namespace	std
namespace	std::hidden

Macros
#define	NOMINMAX

Functions
template<typename OperationType , typename... ArgTypes>
auto	std::apply_operation (OperationType &&operation, const std::tuple< ArgTypes... > &tuple)
template<typename OperationType , typename T , size_t Size>
auto	std::apply_operation (OperationType &&operation, const std::array< T, Size > &array)
template<typename OperationType , typename T , size_t Size>
void	std::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	std::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	std::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	std::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	std::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	std::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	std::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	std::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	std::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	std::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	std::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	std::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	std::operator>= (const std::array< T, Size1 > &array_a, const std::array< T, Size2 > &array_b)
template<typename T , typename S >
auto	std::fail_safe_addition (T &&a, T &&b)
template<typename T , typename S >
auto	std::fail_safe_subtraction (T &&a, T &&b)
template<typename T , typename S >
auto	std::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	std::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	std::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	std::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	std::operator/ (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b)
template<typename T , typename S >
auto	std::fail_safe_addition (T &&a, S &&b)
template<typename T , typename S >
auto	std::fail_safe_subtraction (T &&a, S &&b)
template<typename T , typename S >
auto	std::fail_safe_multiplication (T &&a, S &&b)
template<typename T , typename S >
auto	std::fail_safe_division (T &&a, S &&b)
template<typename... ArgTypes1, typename... ArgTypes2, auto... Indices>
auto	std::hidden::tuple_addition (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b, types::typed_sequence_t< Indices... >)
template<typename T , typename S , auto Size, auto... Indices>
auto	std::hidden::array_equality (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b, types::typed_sequence_t< Indices... >)
template<typename T , typename S , auto Size, auto... Indices>
auto	std::hidden::array_less (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b, types::typed_sequence_t< Indices... >)
template<typename T , typename S , auto Size, auto... Indices>
auto	std::hidden::array_less_equal (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b, types::typed_sequence_t< Indices... >)
template<typename... ArgTypes1, typename... ArgTypes2, auto... Indices>
auto	std::hidden::tuple_subtraction (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b, types::typed_sequence_t< Indices... >)
template<typename... ArgTypes1, typename... ArgTypes2, auto... Indices>
auto	std::hidden::tuple_multiplication (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b, types::typed_sequence_t< Indices... >)
template<typename... ArgTypes1, typename... ArgTypes2, auto... Indices>
auto	std::hidden::tuple_division (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes, auto... Indices>
auto	std::hidden::tuple_addition (const T &scalar, const std::tuple< ArgTypes... > &tuple, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes, auto... Indices>
auto	std::hidden::tuple_addition (const std::tuple< ArgTypes... > &tuple, const T &scalar, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes, auto... Indices>
auto	std::hidden::tuple_subtraction (const T &scalar, const std::tuple< ArgTypes... > &tuple, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes, auto... Indices>
auto	std::hidden::tuple_subtraction (const std::tuple< ArgTypes... > &tuple, const T &scalar, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes, auto... Indices>
auto	std::hidden::tuple_multiplication (const T &scalar, const std::tuple< ArgTypes... > &tuple, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes, auto... Indices>
auto	std::hidden::tuple_multiplication (const std::tuple< ArgTypes... > &tuple, const T &scalar, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes, auto... Indices>
auto	std::hidden::tuple_division (const T &scalar, const std::tuple< ArgTypes... > &tuple, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes, auto... Indices>
auto	std::hidden::tuple_division (const std::tuple< ArgTypes... > &tuple, const T &scalar, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_addition (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_subtraction (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_multiplication (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_division (const std::array< T, Size > &array_a, const std::array< S, Size > &array_b, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_addition (const T &scalar, const std::array< S, Size > &array, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_addition (const std::array< S, Size > &array, const T &scalar, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_subtraction (const T &scalar, const std::array< S, Size > &array, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_subtraction (const std::array< S, Size > &array, const T &scalar, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_multiplication (const T &scalar, const std::array< S, Size > &array, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_multiplication (const std::array< S, Size > &array, const T &scalar, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_division (const T &scalar, const std::array< S, Size > &array, types::typed_sequence_t< Indices... >)
template<typename T , typename S , size_t Size, auto... Indices>
auto	std::hidden::array_division (const std::array< S, Size > &array, const T &scalar, types::typed_sequence_t< Indices... >)
template<typename OperationType , typename... ArgTypes, auto... Indices>
auto	std::hidden::apply_operation (OperationType &&operation, const std::tuple< ArgTypes... > &tuple, types::typed_sequence_t< Indices... >)
template<typename OperationType , typename T , size_t Size, auto... Indices>
auto	std::hidden::apply_operation (OperationType &&operation, const std::array< T, Size > &array, types::typed_sequence_t< Indices... >)
template<typename OperationType , typename T , size_t Size, auto... Indices>
auto	std::hidden::apply_operation_inplace (OperationType &&operation, std::array< T, Size > &array, types::typed_sequence_t< Indices... >)
template<typename T , typename... ArgTypes>
auto	std::operator+ (const T &scalar, const std::tuple< ArgTypes... > &tuple)
template<typename T , typename... ArgTypes>
auto	std::operator+ (const std::tuple< ArgTypes... > &tuple, const T &scalar)
template<typename T , typename... ArgTypes>
auto	std::operator- (const T &scalar, const std::tuple< ArgTypes... > &tuple)
template<typename T , typename... ArgTypes>
auto	std::operator- (const std::tuple< ArgTypes... > &tuple, const T &scalar)
template<typename T , typename... ArgTypes>
auto	std::operator* (const T &scalar, const std::tuple< ArgTypes... > &tuple)
template<typename T , typename... ArgTypes>
auto	std::operator* (const std::tuple< ArgTypes... > &tuple, const T &scalar)
template<typename T , typename... ArgTypes>
auto	std::operator/ (const T &scalar, const std::tuple< ArgTypes... > &tuple)
template<typename T , typename... ArgTypes>
auto	std::operator/ (const std::tuple< ArgTypes... > &tuple, const T &scalar)
template<typename OperationType , typename... ArgTypes>
void	std::apply_operation_inplace (OperationType &&operation, std::tuple< ArgTypes... > &tuple)
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)
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)
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)
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)
template<typename T , typename S , size_t Size>
auto	std::operator+ (const T &scalar, const std::array< S, Size > &array)
template<typename T , typename S , size_t Size>
auto	std::operator+ (const std::array< S, Size > &array, const T &scalar)
template<typename T , typename S , size_t Size>
auto	std::operator- (const T &scalar, const std::array< S, Size > &array)
template<typename T , typename S , size_t Size>
auto	std::operator- (const std::array< S, Size > &array, const T &scalar)
template<typename T , typename S , size_t Size>
auto	std::operator* (const T &scalar, const std::array< S, Size > &array)
template<typename T , typename S , size_t Size>
auto	std::operator* (const std::array< S, Size > &array, const T &scalar)
template<typename T , typename S , size_t Size>
auto	std::operator/ (const T &scalar, const std::array< S, Size > &array)
template<typename T , typename S , size_t Size>
auto	std::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	std::sum_of_elements (const std::tuple< Elements... > &tuple)
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)
template<typename... Elements, typename commom_element_type = types::tuple_common_element_t<std::tuple<Elements...>>>
double	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::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... > >	std::operator/ (const std::variant< EleTypes... > &variant, const T &v)
template<auto N1, auto D1, auto N2, auto D2>
constexpr auto	std::operator* (std::ratio< N1, D1 >, std::ratio< N2, D2 >)
template<auto N1, auto D1, auto N2, auto D2>
constexpr auto	std::operator/ (std::ratio< N1, D1 > a, std::ratio< N2, D2 >)
template<auto N1, auto D1, auto N2, auto D2>
constexpr auto	std::operator+ (std::ratio< N1, D1 >, std::ratio< N2, D2 >)
template<auto N1, auto D1, auto N2, auto D2>
constexpr auto	std::operator- (std::ratio< N1, D1 >, std::ratio< N2, D2 >)

Detailed Description

Type functions are implemented.

Author

Thomas Kim (Thoma.nosp@m.sKim.nosp@m.@Talk.nosp@m.Play.nosp@m.Fun.c.nosp@m.om)

Version

0.1

Date

2021-02-07

Copyright

Copyright (c) 2021

Definition in file tpf_std_extensions.hpp.

Macro Definition Documentation

NOMINMAX

#define NOMINMAX

Definition at line 16 of file tpf_std_extensions.hpp.