stl_extensions Namespace Reference

Namespaces
namespace	hidden

Concepts
concept	append_operator_c
concept	prepend_operator_c

Typedefs
template<typename S , typename T >
using	common_container_t = decltype(hidden::fn_common_container_type(std::declval< std::remove_cvref_t< S > >(), std::declval< std::remove_cvref_t< T > >()))
template<typename TupleA , typename... TupleTypes>
using	tuple_cross_product_t = hidden::tuple_cross_product_t< std::remove_cvref_t< TupleA >, std::remove_cvref_t< TupleTypes >... >
template<typename TupleA , typename... TupleTypes>
using	tuple_cartesian_product_t = tuple_cross_product_t< TupleA, TupleTypes... >
template<cgt::tuple_flat_c TupleType, cgt::tuple_flat_c... TupleTypes>
using	common_signed_tuple_t = hidden::common_signed_tuple_t< std::remove_cvref_t< TupleType >, std::remove_cvref_t< TupleTypes >... >
template<cgt::tuple_flat_c TupleType, cgt::tuple_flat_c... TupleTypes>
using	common_unsigned_tuple_t = hidden::common_unsigned_tuple_t< TupleType, TupleTypes... >
template<typename T , typename S >
using	tuple_scalar_signed_cast = typename hidden::st_tuple_scalar_signed_cast< T, S >::type
template<typename T , typename S >
using	tuple_scalar_unsigned_cast = typename hidden::st_tuple_scalar_unsigned_cast< T, S >::type

Functions
template<cgt::tuple_c Left, cgt::tuple_c Right> requires requires (Left l, Right r) { l + r; }
auto	operator+ (std::vector< Left > const &L, std::vector< Right > const &R)
template<cgt::tuple_c Left, cgt::tuple_c Right> requires requires (Left l, Right r) { l + r; }
auto	operator- (std::vector< Left > const &L, std::vector< Right > const &R)
template<cgt::tuple_c Left, cgt::tuple_c Right> requires requires (Left l, Right r) { l + r; }
auto	operator* (std::vector< Left > const &L, std::vector< Right > const &R)
template<cgt::tuple_c Left, cgt::tuple_c Right> requires requires (Left l, Right r) { l + r; }
auto	operator/ (std::vector< Left > const &L, std::vector< Right > const &R)
template<cgt::vector_c Left, cgt::vector_c Right, std::size_t N> requires requires (Left l, Right r) { l + r; }
auto	operator+ (std::array< Left, N > const &L, std::array< Right, N > const &R)
template<cgt::vector_c Left, cgt::vector_c Right, std::size_t N> requires requires (Left l, Right r) { l + r; }
auto	operator- (std::array< Left, N > const &L, std::array< Right, N > const &R)
template<cgt::vector_c Left, cgt::vector_c Right, std::size_t N> requires requires (Left l, Right r) { l + r; }
auto	operator* (std::array< Left, N > const &L, std::array< Right, N > const &R)
template<cgt::vector_c Left, cgt::vector_c Right, std::size_t N> requires requires (Left l, Right r) { l + r; }
auto	operator/ (std::array< Left, N > const &L, std::array< Right, N > const &R)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && (cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) || (cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator+ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && (cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) || (cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator- (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && (cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) || (cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator* (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && (cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) || (cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator/ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && ( (std::tuple_size_v<std::remove_cvref_t<LeftType>> == 3) || (std::tuple_size_v<std::remove_cvref_t<LeftType>> == 4)) && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator% (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator% (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator% (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator% (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator& (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator& (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>
constexpr decltype(auto)	operator& (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>
constexpr decltype(auto)	operator& (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator+ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator+ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator- (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator- (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator* (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator* (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator/ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType> requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>
constexpr decltype(auto)	operator/ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c ArrayType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator+ (ArrayType &&A, ScalarType s) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c ScalarType, cgt::std_array_flat_c ArrayType>
constexpr decltype(auto)	operator+ (ScalarType s, ArrayType &&A) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c ArrayType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator- (ArrayType &&A, ScalarType s) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c ScalarType, cgt::std_array_flat_c ArrayType>
constexpr decltype(auto)	operator- (ScalarType s, ArrayType &&A) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c ArrayType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator* (ArrayType &&A, ScalarType s) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c ScalarType, cgt::std_array_flat_c ArrayType>
constexpr decltype(auto)	operator* (ScalarType s, ArrayType &&A) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c ArrayType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator/ (ArrayType &&A, ScalarType s) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c ScalarType, cgt::std_array_flat_c ArrayType>
constexpr decltype(auto)	operator/ (ScalarType s, ArrayType &&A) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c H, cgt::numerical_c... Ts>
constexpr decltype(auto)	tuple_to_array (std::tuple< H, Ts... > const &tuple) noexcept
template<cgt::tuple_flat_c H, cgt::tuple_flat_c... Ts> requires (!cgt::all_same_flat_c<H, Ts...>) && (std::tuple_size_v<H> == ... == std::tuple_size_v<Ts>)
constexpr decltype(auto)	tuple_to_array (std::tuple< H, Ts... > const &tuple) noexcept
template<cgt::tuple_flat_c H, cgt::tuple_flat_c... Ts> requires cgt::all_same_flat_c<H, Ts...>
constexpr decltype(auto)	tuple_to_array (std::tuple< H, Ts... > const &tuple) noexcept
template<cgt::numerical_c E, std::size_t N>
constexpr decltype(auto)	array_to_tuple (std::array< E, N > const &array) noexcept
template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts> requires (N == sizeof...(Ts) + 1)
constexpr decltype(auto)	operator+ (std::array< E, N > const &A, std::tuple< H, Ts... > const &T) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts> requires (N == sizeof...(Ts) + 1)
constexpr decltype(auto)	operator+ (std::tuple< H, Ts... > const &T, std::array< E, N > const &A) noexcept(!cpg::bDetectOverFlow)
template<typename E , std::size_t N, typename H , typename... Ts> requires (N == sizeof...(Ts) + 1) && ( !(cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )
constexpr decltype(auto)	operator+ (std::array< E, N > const &A, std::tuple< H, Ts... > const &T) noexcept(!cpg::bDetectOverFlow)
template<typename E , std::size_t N, typename H , typename... Ts> requires (N == sizeof...(Ts) + 1) && ( !( cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )
constexpr decltype(auto)	operator+ (std::tuple< H, Ts... > const &T, std::array< E, N > const &A) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts> requires (N == sizeof...(Ts) + 1)
constexpr decltype(auto)	operator- (std::array< E, N > const &A, std::tuple< H, Ts... > const &T) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts> requires (N == sizeof...(Ts) + 1)
constexpr decltype(auto)	operator- (std::tuple< H, Ts... > const &T, std::array< E, N > const &A) noexcept(!cpg::bDetectOverFlow)
template<typename E , std::size_t N, typename H , typename... Ts> requires (N == sizeof...(Ts) + 1) && ( !(cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )
constexpr decltype(auto)	operator- (std::array< E, N > const &A, std::tuple< H, Ts... > const &T) noexcept(!cpg::bDetectOverFlow)
template<typename E , std::size_t N, typename H , typename... Ts> requires (N == sizeof...(Ts) + 1) && ( !( cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )
constexpr decltype(auto)	operator- (std::tuple< H, Ts... > const &T, std::array< E, N > const &A) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts> requires (N == sizeof...(Ts) + 1)
constexpr decltype(auto)	operator* (std::array< E, N > const &A, std::tuple< H, Ts... > const &T) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts> requires (N == sizeof...(Ts) + 1)
constexpr decltype(auto)	operator* (std::tuple< H, Ts... > const &T, std::array< E, N > const &A) noexcept(!cpg::bDetectOverFlow)
template<typename E , std::size_t N, typename H , typename... Ts> requires (N == sizeof...(Ts) + 1) && ( !(cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )
constexpr decltype(auto)	operator* (std::array< E, N > const &A, std::tuple< H, Ts... > const &T) noexcept(!cpg::bDetectOverFlow)
template<typename E , std::size_t N, typename H , typename... Ts> requires (N == sizeof...(Ts) + 1) && ( !( cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )
constexpr decltype(auto)	operator* (std::tuple< H, Ts... > const &T, std::array< E, N > const &A) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts> requires (N == sizeof...(Ts) + 1)
constexpr decltype(auto)	operator/ (std::array< E, N > const &A, std::tuple< H, Ts... > const &T) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts> requires (N == sizeof...(Ts) + 1)
constexpr decltype(auto)	operator/ (std::tuple< H, Ts... > const &T, std::array< E, N > const &A) noexcept(!cpg::bDetectOverFlow)
template<typename E , std::size_t N, typename H , typename... Ts> requires (N == sizeof...(Ts) + 1) && ( !(cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )
constexpr decltype(auto)	operator/ (std::array< E, N > const &A, std::tuple< H, Ts... > const &T) noexcept(!cpg::bDetectOverFlow)
template<typename E , std::size_t N, typename H , typename... Ts> requires (N == sizeof...(Ts) + 1) && ( !( cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )
constexpr decltype(auto)	operator/ (std::tuple< H, Ts... > const &T, std::array< E, N > const &A) noexcept(!cpg::bDetectOverFlow)
template<template< typename, typename, typename... > class ContainerType, typename EleType , typename Type , typename ... Types, std::common_with< EleType > S> requires requires { container.emplace_back(EleType{}); } || requires { container.emplace(container.end(), EleType{}); } || requires { container.emplace(EleType{}); }
ContainerType< EleType, Type, Types... > &	operator<< (ContainerType< EleType, Type, Types... > &container, S &&s)
	Implace back. More...
template<template< typename, typename, typename... > class ContainerType, typename EleType , typename Type , typename ... Types, std::common_with< EleType > S> requires requires { container.emplace_front(EleType{}); } || requires { container.emplace(container.begin(), EleType{}); } || requires { container.emplace(EleType{}); }
ContainerType< EleType, Type, Types... > &	operator>> (ContainerType< EleType, Type, Types... > &container, S &&s)
	Implace front. More...
template<template< typename, typename, typename... > class ContainerType, typename EleType , typename Type , typename ... Types, cgt::view_flat_c ViewType> requires requires { container.emplace_back(EleType{}); } || requires { container.insert(container.end(), EleType{}); } || requires { container.emplace(EleType{}); }
ContainerType< EleType, Type, Types... > &	operator<< (ContainerType< EleType, Type, Types... > &container, ViewType &&view)
	Implace Back. More...
template<template< typename, typename, typename... > class ContainerType, typename EleType , typename Type , typename ... Types, cgt::view_flat_c ViewType> requires requires { container.emplace_front(EleType{}); } || requires { container.insert(container.begin(), EleType{}); } || requires { container.emplace(EleType{}); }
ContainerType< EleType, Type, Types... > &	operator>> (ContainerType< EleType, Type, Types... > &container, ViewType &&view)
	Implace Front. More...
template<typename CharType >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, cpg::hidden::flush)
template<typename CharType >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, cpg::hidden::endl)
template<typename CharType >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, cpg::hidden::endL)
template<typename CharType >
std::basic_ostringstream< CharType > &	operator<< (std::basic_ostringstream< CharType > &os, cpg::hidden::clear)
template<typename CharType >
std::basic_ostringstream< CharType > &	operator<< (std::basic_ostringstream< CharType > &os, cpg::hidden::flush)
template<typename CharType >
std::basic_ostringstream< CharType > &	operator<< (std::basic_ostringstream< CharType > &os, cpg::hidden::endl)
template<typename CharType >
std::basic_ostringstream< CharType > &	operator<< (std::basic_ostringstream< CharType > &os, cpg::hidden::endL)
template<typename = void>
std::ostream &	operator<< (std::ostream &os, const wchar_t *str)
template<typename = void>
std::ostream &	operator<< (std::ostream &os, std::wstring const &str)
template<typename = void>
std::ostream &	operator<< (std::ostream &os, const char8_t *str)
template<typename = void>
std::ostream &	operator<< (std::ostream &os, std::u8string const &str)
template<typename = void>
std::wostream &	operator<< (std::wostream &os, const char *str)
template<typename = void>
std::wostream &	operator<< (std::wostream &os, const char8_t *str)
template<typename = void>
std::wostream &	operator<< (std::wostream &os, std::u8string const &str)
template<typename CharType >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, std::basic_stringstream< CharType > const &stream)
template<cgt::tuple_flat_c T, cgt::tuple_flat_c S, cgt::tuple_flat_c ... Tails>
constexpr auto	tuple_cartesian_product_type (T A, S B, Tails... tails)
template<typename CharType , typename Type >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, const std::optional< Type > &opt)
template<typename CharType , typename FirstType , typename SecondType >
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, const std::pair< FirstType, SecondType > &pr)
template<typename CharType , typename... Types>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, const std::tuple< Types... > &container)
template<typename CharType , typename Type , typename... Types>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, const std::variant< Type, Types... > &v)
template<typename CharType , typename ContainerType > requires (cgt::std_array_flat_c< ContainerType > || cgt::span_flat_c< ContainerType > || ( cgt::c_array_flat_c<ContainerType> && cgt::non_chars_c<ContainerType> ) )
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, ContainerType &&container)
template<class F , typename T , std::size_t N>
constexpr decltype(auto)	apply (F &&f, T(&&c_array)[N])
template<class F , typename T , std::size_t N>
constexpr decltype(auto)	apply (F &&f, T(&c_array)[N])
template<std::size_t I, class T , std::size_t N>
constexpr decltype(auto)	get (T(&c_array)[N]) noexcept
template<std::size_t I, class T , std::size_t N>
constexpr decltype(auto)	get (T(&&c_array)[N]) noexcept
template<typename CharType , typename T , T... Indices>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, std::integer_sequence< T, Indices... > const &seq) noexcept
template<typename CharType , typename T >
std::basic_ostream< CharType > &	operator>> (std::basic_ostream< CharType > &os, T const &t)
template<typename CharType , typename... Types>
std::basic_ostream< CharType > &	operator>> (std::basic_ostream< CharType > &os, std::tuple< Types... > const &t)
template<cgt::either_array_or_tuple_flat_c T, cgt::either_array_or_tuple_flat_c S, cgt::either_array_or_tuple_flat_c... Tails>
constexpr decltype(auto)	tuple_cartesian_product (T &&A, S &&B, Tails &&... tails)
template<class F , typename T , std::size_t N>
constexpr decltype(auto)	apply (F &&f, std::span< T, N > &sp)
template<class F , typename T , std::size_t N>
constexpr decltype(auto)	apply (F &&f, const std::span< T, N > &sp)
template<class F , typename T , std::size_t N>
constexpr decltype(auto)	apply (F &&f, std::span< T, N > &&sp)
template<typename CharType , cgt::stream_undefined_container_flat_c ContainerType>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, ContainerType &&container)
template<typename CharType , cgt::view_flat_c ViewType>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, ViewType &&view)
template<typename CharType , cgt::map_c ContainerType>
std::basic_ostream< CharType > &	operator<< (std::basic_ostream< CharType > &os, const ContainerType &container)
template<typename T , typename... Tails>
constexpr auto	signed_tuple_operation (T arg, Tails... args) noexcept
template<typename T , typename... Tails>
constexpr auto	unsigned_tuple_operation (T arg, Tails... args) noexcept
template<cgt::tuple_flat_c LeftType, cgt::tuple_flat_c RightType> requires ( std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)
constexpr decltype(auto)	operator+ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c LeftType, cgt::tuple_flat_c RightType> requires ( std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)
constexpr decltype(auto)	operator- (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c LeftType, cgt::tuple_flat_c RightType> requires ( std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)
constexpr decltype(auto)	operator* (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c LeftType, cgt::tuple_flat_c RightType> requires ( std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)
constexpr decltype(auto)	operator/ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator+ (TupleType &&A, ScalarType scalar) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator+ (ScalarType scalar, TupleType &&A) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator- (TupleType &&A, ScalarType scalar) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator- (ScalarType scalar, TupleType &&A) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator* (TupleType &&A, ScalarType scalar) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator* (ScalarType scalar, TupleType &&A) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator/ (TupleType &&A, ScalarType scalar) noexcept(!cpg::bDetectOverFlow)
template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>
constexpr decltype(auto)	operator/ (ScalarType scalar, TupleType &&A) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator+ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator- (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator* (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator/ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator% (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator& (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator+ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator+ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator- (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator- (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator* (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator* (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator/ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator/ (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator% (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator% (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType> requires cgt::std_array_c<cgt::first_type_t<LeftType>> && cgt::numerical_c<cgt::first_type_t<RightType>> && (std::tuple_size_v<cgt::first_type_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)
constexpr decltype(auto)	operator& (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType> requires cgt::numerical_c<cgt::first_type_t<LeftType>> && cgt::std_array_c<cgt::first_type_t<RightType>> && (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<cgt::first_type_t<RightType>>)
constexpr decltype(auto)	operator& (LeftType &&A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::numerical_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator+ (LeftType &&A, RightType B) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator+ (LeftType A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::numerical_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator- (LeftType &&A, RightType B) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator- (LeftType A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::numerical_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator* (LeftType &&A, RightType B) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator* (LeftType A, RightType &&B) noexcept(!cpg::bDetectOverFlow)
template<cgt::vector_c LeftType, cgt::numerical_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator/ (LeftType &&A, RightType B) noexcept(!cpg::bDetectOverFlow)
template<cgt::numerical_c LeftType, cgt::vector_c RightType> requires cgt::common_vector_c<LeftType, RightType>
constexpr decltype(auto)	operator/ (LeftType A, RightType &&B) noexcept(!cpg::bDetectOverFlow)

Typedef Documentation

common_container_t

template<typename S , typename T >

using stl_extensions::common_container_t = typedef decltype(hidden::fn_common_container_type( std::declval<std::remove_cvref_t<S> >(), std::declval<std::remove_cvref_t<T> >()))

Definition at line 163 of file cpg_array_tuple_vector_operations.hpp.

common_signed_tuple_t

template<cgt::tuple_flat_c TupleType, cgt::tuple_flat_c... TupleTypes>

using stl_extensions::common_signed_tuple_t = typedef hidden::common_signed_tuple_t<std::remove_cvref_t<TupleType>, std::remove_cvref_t<TupleTypes>...>

Definition at line 544 of file cpg_std_extensions.hpp.

common_unsigned_tuple_t

template<cgt::tuple_flat_c TupleType, cgt::tuple_flat_c... TupleTypes>

using stl_extensions::common_unsigned_tuple_t = typedef hidden::common_unsigned_tuple_t<TupleType, TupleTypes...>

Definition at line 550 of file cpg_std_extensions.hpp.

tuple_cartesian_product_t

template<typename TupleA , typename... TupleTypes>

using stl_extensions::tuple_cartesian_product_t = typedef tuple_cross_product_t<TupleA, TupleTypes...>

Definition at line 458 of file cpg_std_extensions.hpp.

tuple_cross_product_t

template<typename TupleA , typename... TupleTypes>

using stl_extensions::tuple_cross_product_t = typedef hidden::tuple_cross_product_t< std::remove_cvref_t<TupleA>, std::remove_cvref_t<TupleTypes>...>

Definition at line 454 of file cpg_std_extensions.hpp.

tuple_scalar_signed_cast

template<typename T , typename S >

using stl_extensions::tuple_scalar_signed_cast = typedef typename hidden::st_tuple_scalar_signed_cast<T, S>::type

Definition at line 325 of file cpg_tuple_operations.hpp.

tuple_scalar_unsigned_cast

template<typename T , typename S >

using stl_extensions::tuple_scalar_unsigned_cast = typedef typename hidden::st_tuple_scalar_unsigned_cast<T, S>::type

Definition at line 328 of file cpg_tuple_operations.hpp.

Function Documentation

apply() [1/5]

template<class F , typename T , std::size_t N>

constexpr decltype(auto) stl_extensions::apply ( F &&  f, const std::span< T, N > &  sp  )

constexpr

Definition at line 836 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

apply() [2/5]

template<class F , typename T , std::size_t N>

constexpr decltype(auto) stl_extensions::apply ( F &&  f, std::span< T, N > &&  sp  )

constexpr

Definition at line 845 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

apply() [3/5]

template<class F , typename T , std::size_t N>

constexpr decltype(auto) stl_extensions::apply ( F &&  f, std::span< T, N > &  sp  )

constexpr

Definition at line 827 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

apply() [4/5]

template<class F , typename T , std::size_t N>

constexpr decltype(auto) stl_extensions::apply ( F &&  f, T(&&)  c_array[N]  )

constexpr

Here is the caller graph for this function:

apply() [5/5]

template<class F , typename T , std::size_t N>

constexpr decltype(auto) stl_extensions::apply ( F &&  f, T(&)  c_array[N]  )

constexpr

array_to_tuple()

template<cgt::numerical_c E, std::size_t N>

constexpr decltype(auto) stl_extensions::array_to_tuple ( std::array< E, N > const &  array )

constexprnoexcept

Definition at line 59 of file cpg_std_array_tuple_operations.hpp.

get() [1/2]

template<std::size_t I, class T , std::size_t N>

constexpr decltype(auto) stl_extensions::get ( T(&&)  c_array[N] )

constexprnoexcept

Definition at line 804 of file cpg_std_extensions.hpp.

get() [2/2]

template<std::size_t I, class T , std::size_t N>

constexpr decltype(auto) stl_extensions::get ( T(&)  c_array[N] )

constexprnoexcept

Definition at line 798 of file cpg_std_extensions.hpp.

Here is the caller graph for this function:

operator%() [1/7]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && ( (std::tuple_size_v<std::remove_cvref_t<LeftType>> == 3) || (std::tuple_size_v<std::remove_cvref_t<LeftType>> == 4)) && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator% ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 198 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator%() [2/7]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator% ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 223 of file cpg_std_array_operations.hpp.

operator%() [3/7]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator% ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 261 of file cpg_std_array_operations.hpp.

operator%() [4/7]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator% ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 290 of file cpg_std_array_operations.hpp.

operator%() [5/7]

template<cgt::vector_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator% ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 179 of file cpg_vector_operations.hpp.

operator%() [6/7]

template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator% ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 442 of file cpg_vector_operations.hpp.

operator%() [7/7]

template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator% ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 469 of file cpg_vector_operations.hpp.

operator&() [1/7]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator& ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 327 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator&() [2/7]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator& ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 352 of file cpg_std_array_operations.hpp.

operator&() [3/7]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>

constexpr decltype(auto) stl_extensions::operator& ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 375 of file cpg_std_array_operations.hpp.

operator&() [4/7]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>

constexpr decltype(auto) stl_extensions::operator& ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 395 of file cpg_std_array_operations.hpp.

operator&() [5/7]

template<cgt::vector_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator& ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 220 of file cpg_vector_operations.hpp.

operator&() [6/7]

template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::std_array_c<cgt::first_type_t<LeftType>> && cgt::numerical_c<cgt::first_type_t<RightType>> && (std::tuple_size_v<cgt::first_type_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator& ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 495 of file cpg_vector_operations.hpp.

operator&() [7/7]

template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType>
requires cgt::numerical_c<cgt::first_type_t<LeftType>> && cgt::std_array_c<cgt::first_type_t<RightType>> && (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator& ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 517 of file cpg_vector_operations.hpp.

operator*() [1/19]

template<cgt::std_array_flat_c ArrayType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator* ( ArrayType &&  A, ScalarType  s  )

constexprnoexcept

Definition at line 758 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator*() [2/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && (cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) || (cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator* ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 113 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator*() [3/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator* ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 538 of file cpg_std_array_operations.hpp.

operator*() [4/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator* ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 567 of file cpg_std_array_operations.hpp.

operator*() [5/19]

template<cgt::tuple_flat_c LeftType, cgt::tuple_flat_c RightType>
requires ( std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator* ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 211 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator*() [6/19]

template<cgt::vector_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator* ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 100 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator*() [7/19]

template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator* ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 344 of file cpg_vector_operations.hpp.

operator*() [8/19]

template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator* ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 368 of file cpg_vector_operations.hpp.

operator*() [9/19]

template<cgt::vector_c LeftType, cgt::numerical_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator* ( LeftType &&  A, RightType  B  )

constexprnoexcept

Definition at line 645 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator*() [10/19]

template<cgt::numerical_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator* ( LeftType  A, RightType &&  B  )

constexprnoexcept

Definition at line 672 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator*() [11/19]

template<cgt::numerical_c ScalarType, cgt::std_array_flat_c ArrayType>

constexpr decltype(auto) stl_extensions::operator* ( ScalarType  s, ArrayType &&  A  )

constexprnoexcept

Definition at line 785 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator*() [12/19]

template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator* ( ScalarType  scalar, TupleType &&  A  )

constexprnoexcept

Definition at line 461 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator*() [13/19]

template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts>
requires (N == sizeof...(Ts) + 1)

constexpr decltype(auto) stl_extensions::operator* ( std::array< E, N > const &  A, std::tuple< H, Ts... > const &  T  )

constexprnoexcept

Definition at line 201 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

operator*() [14/19]

template<typename E , std::size_t N, typename H , typename... Ts>
requires (N == sizeof...(Ts) + 1) && ( !(cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )

constexpr decltype(auto) stl_extensions::operator* ( std::array< E, N > const &  A, std::tuple< H, Ts... > const &  T  )

constexprnoexcept

Definition at line 230 of file cpg_std_array_tuple_operations.hpp.

operator*() [15/19]

template<cgt::vector_c Left, cgt::vector_c Right, std::size_t N>
requires requires (Left l, Right r) { l + r; }

auto stl_extensions::operator*	(	std::array< Left, N > const &	L,
		std::array< Right, N > const &	R
	)

Definition at line 125 of file cpg_array_tuple_vector_operations.hpp.

operator*() [16/19]

template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts>
requires (N == sizeof...(Ts) + 1)

constexpr decltype(auto) stl_extensions::operator* ( std::tuple< H, Ts... > const &  T, std::array< E, N > const &  A  )

constexprnoexcept

Definition at line 215 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

operator*() [17/19]

template<typename E , std::size_t N, typename H , typename... Ts>
requires (N == sizeof...(Ts) + 1) && ( !( cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )

constexpr decltype(auto) stl_extensions::operator* ( std::tuple< H, Ts... > const &  T, std::array< E, N > const &  A  )

constexprnoexcept

Definition at line 245 of file cpg_std_array_tuple_operations.hpp.

operator*() [18/19]

template<cgt::tuple_c Left, cgt::tuple_c Right>
requires requires (Left l, Right r) { l + r; }

auto stl_extensions::operator*	(	std::vector< Left > const &	L,
		std::vector< Right > const &	R
	)

Definition at line 60 of file cpg_array_tuple_vector_operations.hpp.

operator*() [19/19]

template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator* ( TupleType &&  A, ScalarType  scalar  )

constexprnoexcept

Definition at line 435 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator+() [1/19]

template<cgt::std_array_flat_c ArrayType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator+ ( ArrayType &&  A, ScalarType  s  )

constexprnoexcept

Definition at line 650 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator+() [2/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && (cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) || (cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator+ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 29 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator+() [3/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator+ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 421 of file cpg_std_array_operations.hpp.

operator+() [4/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator+ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 450 of file cpg_std_array_operations.hpp.

operator+() [5/19]

template<cgt::tuple_flat_c LeftType, cgt::tuple_flat_c RightType>
requires ( std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator+ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 125 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator+() [6/19]

template<cgt::vector_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator+ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 24 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator+() [7/19]

template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator+ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 246 of file cpg_vector_operations.hpp.

operator+() [8/19]

template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator+ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 270 of file cpg_vector_operations.hpp.

operator+() [9/19]

template<cgt::vector_c LeftType, cgt::numerical_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator+ ( LeftType &&  A, RightType  B  )

constexprnoexcept

Definition at line 537 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator+() [10/19]

template<cgt::numerical_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator+ ( LeftType  A, RightType &&  B  )

constexprnoexcept

Definition at line 564 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator+() [11/19]

template<cgt::numerical_c ScalarType, cgt::std_array_flat_c ArrayType>

constexpr decltype(auto) stl_extensions::operator+ ( ScalarType  s, ArrayType &&  A  )

constexprnoexcept

Definition at line 677 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator+() [12/19]

template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator+ ( ScalarType  scalar, TupleType &&  A  )

constexprnoexcept

Definition at line 357 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator+() [13/19]

template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts>
requires (N == sizeof...(Ts) + 1)

constexpr decltype(auto) stl_extensions::operator+ ( std::array< E, N > const &  A, std::tuple< H, Ts... > const &  T  )

constexprnoexcept

Definition at line 81 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

operator+() [14/19]

template<typename E , std::size_t N, typename H , typename... Ts>
requires (N == sizeof...(Ts) + 1) && ( !(cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )

constexpr decltype(auto) stl_extensions::operator+ ( std::array< E, N > const &  A, std::tuple< H, Ts... > const &  T  )

constexprnoexcept

Definition at line 110 of file cpg_std_array_tuple_operations.hpp.

operator+() [15/19]

template<cgt::vector_c Left, cgt::vector_c Right, std::size_t N>
requires requires (Left l, Right r) { l + r; }

auto stl_extensions::operator+	(	std::array< Left, N > const &	L,
		std::array< Right, N > const &	R
	)

Definition at line 94 of file cpg_array_tuple_vector_operations.hpp.

operator+() [16/19]

template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts>
requires (N == sizeof...(Ts) + 1)

constexpr decltype(auto) stl_extensions::operator+ ( std::tuple< H, Ts... > const &  T, std::array< E, N > const &  A  )

constexprnoexcept

Definition at line 95 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

operator+() [17/19]

template<typename E , std::size_t N, typename H , typename... Ts>
requires (N == sizeof...(Ts) + 1) && ( !( cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )

constexpr decltype(auto) stl_extensions::operator+ ( std::tuple< H, Ts... > const &  T, std::array< E, N > const &  A  )

constexprnoexcept

Definition at line 125 of file cpg_std_array_tuple_operations.hpp.

operator+() [18/19]

template<cgt::tuple_c Left, cgt::tuple_c Right>
requires requires (Left l, Right r) { l + r; }

auto stl_extensions::operator+	(	std::vector< Left > const &	L,
		std::vector< Right > const &	R
	)

Definition at line 26 of file cpg_array_tuple_vector_operations.hpp.

operator+() [19/19]

template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator+ ( TupleType &&  A, ScalarType  scalar  )

constexprnoexcept

Definition at line 331 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator-() [1/19]

template<cgt::std_array_flat_c ArrayType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator- ( ArrayType &&  A, ScalarType  s  )

constexprnoexcept

Definition at line 704 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator-() [2/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && (cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) || (cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator- ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 71 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator-() [3/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator- ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 480 of file cpg_std_array_operations.hpp.

operator-() [4/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator- ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 509 of file cpg_std_array_operations.hpp.

operator-() [5/19]

template<cgt::tuple_flat_c LeftType, cgt::tuple_flat_c RightType>
requires ( std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator- ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 168 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator-() [6/19]

template<cgt::vector_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator- ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 62 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator-() [7/19]

template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator- ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 295 of file cpg_vector_operations.hpp.

operator-() [8/19]

template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator- ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 319 of file cpg_vector_operations.hpp.

operator-() [9/19]

template<cgt::vector_c LeftType, cgt::numerical_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator- ( LeftType &&  A, RightType  B  )

constexprnoexcept

Definition at line 591 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator-() [10/19]

template<cgt::numerical_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator- ( LeftType  A, RightType &&  B  )

constexprnoexcept

Definition at line 618 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator-() [11/19]

template<cgt::numerical_c ScalarType, cgt::std_array_flat_c ArrayType>

constexpr decltype(auto) stl_extensions::operator- ( ScalarType  s, ArrayType &&  A  )

constexprnoexcept

Definition at line 731 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator-() [12/19]

template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator- ( ScalarType  scalar, TupleType &&  A  )

constexprnoexcept

Definition at line 409 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator-() [13/19]

template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts>
requires (N == sizeof...(Ts) + 1)

constexpr decltype(auto) stl_extensions::operator- ( std::array< E, N > const &  A, std::tuple< H, Ts... > const &  T  )

constexprnoexcept

Definition at line 141 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

operator-() [14/19]

template<typename E , std::size_t N, typename H , typename... Ts>
requires (N == sizeof...(Ts) + 1) && ( !(cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )

constexpr decltype(auto) stl_extensions::operator- ( std::array< E, N > const &  A, std::tuple< H, Ts... > const &  T  )

constexprnoexcept

Definition at line 170 of file cpg_std_array_tuple_operations.hpp.

operator-() [15/19]

template<cgt::vector_c Left, cgt::vector_c Right, std::size_t N>
requires requires (Left l, Right r) { l + r; }

auto stl_extensions::operator-	(	std::array< Left, N > const &	L,
		std::array< Right, N > const &	R
	)

Definition at line 109 of file cpg_array_tuple_vector_operations.hpp.

operator-() [16/19]

template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts>
requires (N == sizeof...(Ts) + 1)

constexpr decltype(auto) stl_extensions::operator- ( std::tuple< H, Ts... > const &  T, std::array< E, N > const &  A  )

constexprnoexcept

Definition at line 155 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

operator-() [17/19]

template<typename E , std::size_t N, typename H , typename... Ts>
requires (N == sizeof...(Ts) + 1) && ( !( cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )

constexpr decltype(auto) stl_extensions::operator- ( std::tuple< H, Ts... > const &  T, std::array< E, N > const &  A  )

constexprnoexcept

Definition at line 185 of file cpg_std_array_tuple_operations.hpp.

operator-() [18/19]

template<cgt::tuple_c Left, cgt::tuple_c Right>
requires requires (Left l, Right r) { l + r; }

auto stl_extensions::operator-	(	std::vector< Left > const &	L,
		std::vector< Right > const &	R
	)

Definition at line 43 of file cpg_array_tuple_vector_operations.hpp.

operator-() [19/19]

template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator- ( TupleType &&  A, ScalarType  scalar  )

constexprnoexcept

Definition at line 383 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator/() [1/19]

template<cgt::std_array_flat_c ArrayType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator/ ( ArrayType &&  A, ScalarType  s  )

constexprnoexcept

Definition at line 812 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator/() [2/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires (std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>) && (cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) || (cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>>) && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator/ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 155 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator/() [3/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator/ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 596 of file cpg_std_array_operations.hpp.

operator/() [4/19]

template<cgt::std_array_flat_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::numerical_c<std::tuple_element_t<0, std::remove_cvref_t<LeftType>>> && cgt::std_array_c<std::tuple_element_t<0, std::remove_cvref_t<RightType>>> && cgt::common_std_array_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator/ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 625 of file cpg_std_array_operations.hpp.

operator/() [5/19]

template<cgt::tuple_flat_c LeftType, cgt::tuple_flat_c RightType>
requires ( std::tuple_size_v<std::remove_cvref_t<LeftType>> == std::tuple_size_v<std::remove_cvref_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator/ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 254 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator/() [6/19]

template<cgt::vector_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator/ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 138 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator/() [7/19]

template<cgt::vector_c LeftType, cgt::std_array_flat_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::std_array_c<cgt::first_type_t<LeftType>>) && (cgt::numerical_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator/ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 393 of file cpg_vector_operations.hpp.

operator/() [8/19]

template<cgt::std_array_flat_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType> && (cgt::numerical_c<cgt::first_type_t<LeftType>>) && (cgt::std_array_c<cgt::first_type_t<RightType>>)

constexpr decltype(auto) stl_extensions::operator/ ( LeftType &&  A, RightType &&  B  )

constexprnoexcept

Definition at line 417 of file cpg_vector_operations.hpp.

operator/() [9/19]

template<cgt::vector_c LeftType, cgt::numerical_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator/ ( LeftType &&  A, RightType  B  )

constexprnoexcept

Definition at line 699 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator/() [10/19]

template<cgt::numerical_c LeftType, cgt::vector_c RightType>
requires cgt::common_vector_c<LeftType, RightType>

constexpr decltype(auto) stl_extensions::operator/ ( LeftType  A, RightType &&  B  )

constexprnoexcept

Definition at line 726 of file cpg_vector_operations.hpp.

Here is the call graph for this function:

operator/() [11/19]

template<cgt::numerical_c ScalarType, cgt::std_array_flat_c ArrayType>

constexpr decltype(auto) stl_extensions::operator/ ( ScalarType  s, ArrayType &&  A  )

constexprnoexcept

Definition at line 839 of file cpg_std_array_operations.hpp.

Here is the call graph for this function:

operator/() [12/19]

template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator/ ( ScalarType  scalar, TupleType &&  A  )

constexprnoexcept

Definition at line 513 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator/() [13/19]

template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts>
requires (N == sizeof...(Ts) + 1)

constexpr decltype(auto) stl_extensions::operator/ ( std::array< E, N > const &  A, std::tuple< H, Ts... > const &  T  )

constexprnoexcept

Definition at line 261 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

operator/() [14/19]

template<typename E , std::size_t N, typename H , typename... Ts>
requires (N == sizeof...(Ts) + 1) && ( !(cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )

constexpr decltype(auto) stl_extensions::operator/ ( std::array< E, N > const &  A, std::tuple< H, Ts... > const &  T  )

constexprnoexcept

Definition at line 290 of file cpg_std_array_tuple_operations.hpp.

operator/() [15/19]

template<cgt::vector_c Left, cgt::vector_c Right, std::size_t N>
requires requires (Left l, Right r) { l + r; }

auto stl_extensions::operator/	(	std::array< Left, N > const &	L,
		std::array< Right, N > const &	R
	)

Definition at line 140 of file cpg_array_tuple_vector_operations.hpp.

operator/() [16/19]

template<cgt::numerical_c E, std::size_t N, cgt::numerical_c H, cgt::numerical_c... Ts>
requires (N == sizeof...(Ts) + 1)

constexpr decltype(auto) stl_extensions::operator/ ( std::tuple< H, Ts... > const &  T, std::array< E, N > const &  A  )

constexprnoexcept

Definition at line 275 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

operator/() [17/19]

template<typename E , std::size_t N, typename H , typename... Ts>
requires (N == sizeof...(Ts) + 1) && ( !( cgt::numerical_c<E> && (cgt::numerical_c<H> && ... && cgt::numerical_c<Ts>)) )

constexpr decltype(auto) stl_extensions::operator/ ( std::tuple< H, Ts... > const &  T, std::array< E, N > const &  A  )

constexprnoexcept

Definition at line 305 of file cpg_std_array_tuple_operations.hpp.

operator/() [18/19]

template<cgt::tuple_c Left, cgt::tuple_c Right>
requires requires (Left l, Right r) { l + r; }

auto stl_extensions::operator/	(	std::vector< Left > const &	L,
		std::vector< Right > const &	R
	)

Definition at line 77 of file cpg_array_tuple_vector_operations.hpp.

operator/() [19/19]

template<cgt::tuple_flat_c TupleType, cgt::numerical_c ScalarType>

constexpr decltype(auto) stl_extensions::operator/ ( TupleType &&  A, ScalarType  scalar  )

constexprnoexcept

Definition at line 487 of file cpg_tuple_operations.hpp.

Here is the call graph for this function:

operator<<() [1/26]

template<template< typename, typename, typename... > class ContainerType, typename EleType , typename Type , typename ... Types, std::common_with< EleType > S>
requires requires { container.emplace_back(EleType{}); } || requires { container.emplace(container.end(), EleType{}); } || requires { container.emplace(EleType{}); }

ContainerType< EleType, Type, Types... > & stl_extensions::operator<<	(	ContainerType< EleType, Type, Types... > &	container,
		S &&	s
	)

Implace back.

Definition at line 16 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator<<() [2/26]

template<template< typename, typename, typename... > class ContainerType, typename EleType , typename Type , typename ... Types, cgt::view_flat_c ViewType>
requires requires { container.emplace_back(EleType{}); } || requires { container.insert(container.end(), EleType{}); } || requires { container.emplace(EleType{}); }

ContainerType< EleType, Type, Types... > & stl_extensions::operator<<	(	ContainerType< EleType, Type, Types... > &	container,
		ViewType &&	view
	)

Implace Back.

Definition at line 125 of file cpg_std_extensions.hpp.

operator<<() [3/26]

template<typename CharType , cgt::map_c ContainerType>

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		const ContainerType &	container
	)

Definition at line 845 of file cpg_std_extensions.hpp.

Here is the caller graph for this function:

operator<<() [4/26]

template<typename CharType , typename Type >

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		const std::optional< Type > &	opt
	)

Definition at line 845 of file cpg_std_extensions.hpp.

operator<<() [5/26]

template<typename CharType , typename FirstType , typename SecondType >

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		const std::pair< FirstType, SecondType > &	pr
	)

Definition at line 434 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator<<() [6/26]

template<typename CharType , typename... Types>

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		const std::tuple< Types... > &	container
	)

Definition at line 845 of file cpg_std_extensions.hpp.

operator<<() [7/26]

template<typename CharType , typename Type , typename... Types>

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		const std::variant< Type, Types... > &	v
	)

Definition at line 845 of file cpg_std_extensions.hpp.

operator<<() [8/26]

template<typename CharType , cgt::stream_undefined_container_flat_c ContainerType>

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		ContainerType &&	container
	)

Definition at line 845 of file cpg_std_extensions.hpp.

operator<<() [9/26]

template<typename CharType , typename ContainerType >
requires (cgt::std_array_flat_c< ContainerType > || cgt::span_flat_c< ContainerType > || ( cgt::c_array_flat_c<ContainerType> && cgt::non_chars_c<ContainerType> ) )

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		ContainerType &&	container
	)

Definition at line 845 of file cpg_std_extensions.hpp.

operator<<() [10/26]

template<typename CharType >

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		cpg::hidden::endL
	)

Definition at line 207 of file cpg_std_extensions.hpp.

operator<<() [11/26]

template<typename CharType >

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		cpg::hidden::endl
	)

Definition at line 207 of file cpg_std_extensions.hpp.

operator<<() [12/26]

template<typename CharType >

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		cpg::hidden::flush
	)

Definition at line 207 of file cpg_std_extensions.hpp.

operator<<() [13/26]

template<typename CharType >

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		std::basic_stringstream< CharType > const &	stream
	)

Definition at line 388 of file cpg_std_extensions.hpp.

operator<<() [14/26]

template<typename CharType , typename T , T... Indices>

std::basic_ostream< CharType > & stl_extensions::operator<< ( std::basic_ostream< CharType > &  os, std::integer_sequence< T, Indices... > const &  seq  )

noexcept

Definition at line 708 of file cpg_std_extensions.hpp.

operator<<() [15/26]

template<typename CharType , cgt::view_flat_c ViewType>

std::basic_ostream< CharType > & stl_extensions::operator<<	(	std::basic_ostream< CharType > &	os,
		ViewType &&	view
	)

Definition at line 845 of file cpg_std_extensions.hpp.

operator<<() [16/26]

template<typename CharType >

std::basic_ostringstream< CharType > & stl_extensions::operator<<	(	std::basic_ostringstream< CharType > &	os,
		cpg::hidden::clear
	)

Definition at line 207 of file cpg_std_extensions.hpp.

operator<<() [17/26]

template<typename CharType >

std::basic_ostringstream< CharType > & stl_extensions::operator<<	(	std::basic_ostringstream< CharType > &	os,
		cpg::hidden::endL
	)

Definition at line 207 of file cpg_std_extensions.hpp.

operator<<() [18/26]

template<typename CharType >

std::basic_ostringstream< CharType > & stl_extensions::operator<<	(	std::basic_ostringstream< CharType > &	os,
		cpg::hidden::endl
	)

Definition at line 207 of file cpg_std_extensions.hpp.

operator<<() [19/26]

template<typename CharType >

std::basic_ostringstream< CharType > & stl_extensions::operator<<	(	std::basic_ostringstream< CharType > &	os,
		cpg::hidden::flush
	)

Definition at line 207 of file cpg_std_extensions.hpp.

operator<<() [20/26]

template<typename = void>

std::ostream & stl_extensions::operator<<	(	std::ostream &	os,
		const char8_t *	str
	)

Definition at line 356 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator<<() [21/26]

template<typename = void>

std::ostream & stl_extensions::operator<<	(	std::ostream &	os,
		const wchar_t *	str
	)

Definition at line 340 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator<<() [22/26]

template<typename = void>

std::ostream & stl_extensions::operator<<	(	std::ostream &	os,
		std::u8string const &	str
	)

Definition at line 364 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator<<() [23/26]

template<typename = void>

std::ostream & stl_extensions::operator<<	(	std::ostream &	os,
		std::wstring const &	str
	)

Definition at line 348 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator<<() [24/26]

template<typename = void>

std::wostream & stl_extensions::operator<<	(	std::wostream &	os,
		const char *	str
	)

Definition at line 372 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator<<() [25/26]

template<typename = void>

std::wostream & stl_extensions::operator<<	(	std::wostream &	os,
		const char8_t *	str
	)

Definition at line 380 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator<<() [26/26]

template<typename = void>

std::wostream & stl_extensions::operator<<	(	std::wostream &	os,
		std::u8string const &	str
	)

Definition at line 388 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

operator>>() [1/4]

template<template< typename, typename, typename... > class ContainerType, typename EleType , typename Type , typename ... Types, std::common_with< EleType > S>
requires requires { container.emplace_front(EleType{}); } || requires { container.emplace(container.begin(), EleType{}); } || requires { container.emplace(EleType{}); }

ContainerType< EleType, Type, Types... > & stl_extensions::operator>>	(	ContainerType< EleType, Type, Types... > &	container,
		S &&	s
	)

Implace front.

Definition at line 125 of file cpg_std_extensions.hpp.

operator>>() [2/4]

template<template< typename, typename, typename... > class ContainerType, typename EleType , typename Type , typename ... Types, cgt::view_flat_c ViewType>
requires requires { container.emplace_front(EleType{}); } || requires { container.insert(container.begin(), EleType{}); } || requires { container.emplace(EleType{}); }

ContainerType< EleType, Type, Types... > & stl_extensions::operator>>	(	ContainerType< EleType, Type, Types... > &	container,
		ViewType &&	view
	)

Implace Front.

Definition at line 207 of file cpg_std_extensions.hpp.

operator>>() [3/4]

template<typename CharType , typename... Types>

std::basic_ostream< CharType > & stl_extensions::operator>>	(	std::basic_ostream< CharType > &	os,
		std::tuple< Types... > const &	t
	)

Definition at line 708 of file cpg_std_extensions.hpp.

operator>>() [4/4]

template<typename CharType , typename T >

std::basic_ostream< CharType > & stl_extensions::operator>>	(	std::basic_ostream< CharType > &	os,
		T const &	t
	)

Definition at line 693 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

signed_tuple_operation()

template<typename T , typename... Tails>

constexpr auto stl_extensions::signed_tuple_operation ( T  arg, Tails...  args  )

constexprnoexcept

Definition at line 109 of file cpg_tuple_operations.hpp.

Here is the caller graph for this function:

tuple_cartesian_product()

template<cgt::either_array_or_tuple_flat_c T, cgt::either_array_or_tuple_flat_c S, cgt::either_array_or_tuple_flat_c... Tails>

constexpr decltype(auto) stl_extensions::tuple_cartesian_product ( T &&  A, S &&  B, Tails &&...  tails  )

constexpr

Definition at line 680 of file cpg_std_extensions.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

tuple_cartesian_product_type()

template<cgt::tuple_flat_c T, cgt::tuple_flat_c S, cgt::tuple_flat_c ... Tails>

constexpr auto stl_extensions::tuple_cartesian_product_type ( T  A, S  B, Tails...  tails  )

constexpr

Definition at line 434 of file cpg_std_extensions.hpp.

Here is the caller graph for this function:

tuple_to_array() [1/3]

template<cgt::numerical_c H, cgt::numerical_c... Ts>

constexpr decltype(auto) stl_extensions::tuple_to_array ( std::tuple< H, Ts... > const &  tuple )

constexprnoexcept

Definition at line 22 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

tuple_to_array() [2/3]

template<cgt::tuple_flat_c H, cgt::tuple_flat_c... Ts>
requires (!cgt::all_same_flat_c<H, Ts...>) && (std::tuple_size_v<H> == ... == std::tuple_size_v<Ts>)

constexpr decltype(auto) stl_extensions::tuple_to_array ( std::tuple< H, Ts... > const &  tuple )

constexprnoexcept

Definition at line 36 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

tuple_to_array() [3/3]

template<cgt::tuple_flat_c H, cgt::tuple_flat_c... Ts>
requires cgt::all_same_flat_c<H, Ts...>

constexpr decltype(auto) stl_extensions::tuple_to_array ( std::tuple< H, Ts... > const &  tuple )

constexprnoexcept

Definition at line 49 of file cpg_std_array_tuple_operations.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned_tuple_operation()

template<typename T , typename... Tails>

constexpr auto stl_extensions::unsigned_tuple_operation ( T  arg, Tails...  args  )

constexprnoexcept

Definition at line 116 of file cpg_tuple_operations.hpp.