tim::math Namespace Reference

Classes
struct	compute
	Struct for performing math operations on complex data structures without using globally overload operators (e.g. lhs += rhs) and generic functions (lhs = abs(rhs)) More...
struct	compute< null_type, null_type >
struct	compute< type_list<>, type_list<> >

Functions
template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0, enable_if_t< std::is_integral< Tp >::value &&std::is_unsigned< Tp >::value > = 0>
auto	abs (Tp _val, type_list<>) -> decltype(Tp{})
template<typename Tp , typename Vp = typename Tp::value_type>
auto	abs (Tp _val, type_list<>,...) -> decltype(std::begin(_val), Tp{})
template<template< typename... > class Tuple, typename... Types, size_t... Idx>
auto	abs (Tuple< Types... > _val, index_sequence< Idx... >) -> decltype(std::get< 0 >(_val), Tuple< Types... >())
template<typename Tp >
Tp	abs (Tp _val)
template<typename Tp , typename Up >
void	assign (Tp &_lhs, Up &&_rhs)
template<typename Tp , typename Up >
auto	divide (Tp &_lhs, Up _rhs, type_list<>,...) -> decltype(_lhs/=_rhs, void())
template<typename Tp , typename Up , typename Vp = typename Tp::value_type, enable_if_t<!std::is_arithmetic< Up >::value > = 0>
auto	divide (Tp &_lhs, const Up &_rhs, type_list<>, long) -> decltype(std::begin(_lhs), void())
template<typename Tp , typename Up , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type, enable_if_t<!std::is_arithmetic< Up >::value > = 0>
auto	divide (Tp &_lhs, const Up &_rhs, type_list<>, int) -> decltype(std::begin(_lhs), void())
template<typename Tp , typename Up >
auto	divide (Tp &, const Up &, index_sequence<>, int)
template<typename Tp , typename Up , size_t... Idx, enable_if_t<!std::is_arithmetic< Up >::value > = 0>
auto	divide (Tp &_lhs, const Up &_rhs, index_sequence< Idx... >, long) -> decltype(std::get< 0 >(_lhs), void())
template<typename Tp , typename Up , enable_if_t<!concepts::is_null_type< Tp >::value > >
Tp &	divide (Tp &_lhs, const Up &_rhs)
template<typename Tp >
bool	is_finite (const Tp &val)
template<typename Tp >
Tp	sqrt (Tp)
template<typename Tp >
Tp	pow (Tp, double)
template<typename Tp >
Tp	sqr (Tp)
template<typename Tp >
Tp	min (const Tp &, const Tp &)
template<typename Tp >
Tp	max (const Tp &, const Tp &)
template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>
Tp &	plus (Tp &, const Up &)
template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>
Tp &	minus (Tp &, const Up &)
template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>
Tp &	multiply (Tp &, const Up &)
template<typename Tp >
Tp	percent_diff (const Tp &, const Tp &)
std::tuple	abs (std::tuple<>)
std::tuple	sqrt (std::tuple<>)
std::tuple	pow (std::tuple<>, double)
std::tuple	sqr (std::tuple<>)
std::tuple	min (const std::tuple<> &, const std::tuple<> &)
std::tuple	max (const std::tuple<> &, const std::tuple<> &)
void	assign (std::tuple<> &, std::tuple<> &&)
std::tuple &	plus (std::tuple<> &lhs, const std::tuple<> &)
std::tuple &	minus (std::tuple<> &lhs, const std::tuple<> &)
std::tuple &	multiply (std::tuple<> &lhs, const std::tuple<> &)
std::tuple &	divide (std::tuple<> &lhs, const std::tuple<> &)
std::tuple	percent_diff (const std::tuple<> &, const std::tuple<> &)
template<typename Up >
std::tuple &	plus (std::tuple<> &lhs, Up &&)
template<typename Up >
std::tuple &	minus (std::tuple<> &lhs, Up &&)
template<typename Up >
std::tuple &	multiply (std::tuple<> &lhs, Up &&)
template<typename Up >
std::tuple &	divide (std::tuple<> &lhs, Up &&)
std::tuple &	divide (std::tuple<> &lhs, uint64_t)
std::tuple &	divide (std::tuple<> &lhs, int64_t)
null_type	abs (null_type)
null_type	sqrt (null_type)
null_type	pow (null_type, double)
null_type	sqr (null_type)
null_type	min (const null_type &, const null_type &)
null_type	max (const null_type &, const null_type &)
void	assign (null_type &, null_type &&)
null_type &	plus (null_type &lhs, const null_type &)
null_type &	minus (null_type &lhs, const null_type &)
null_type &	multiply (null_type &lhs, const null_type &)
null_type &	divide (null_type &lhs, const null_type &)
null_type	percent_diff (const null_type &, const null_type &)
template<typename Up >
null_type &	plus (null_type &lhs, Up &&)
template<typename Up >
null_type &	minus (null_type &lhs, Up &&)
template<typename Up >
null_type &	multiply (null_type &lhs, Up &&)
template<typename Up >
null_type &	divide (null_type &lhs, Up &&)
null_type &	divide (null_type &lhs, uint64_t)
null_type &	divide (null_type &lhs, int64_t)
type_list	pow (type_list<>, double)
type_list	min (const type_list<> &, const type_list<> &)
type_list	max (const type_list<> &, const type_list<> &)
void	assign (type_list<> &, type_list<> &&)
type_list &	plus (type_list<> &lhs, const type_list<> &)
type_list &	minus (type_list<> &lhs, const type_list<> &)
type_list &	multiply (type_list<> &lhs, const type_list<> &)
type_list &	divide (type_list<> &lhs, const type_list<> &)
type_list	percent_diff (const type_list<> &, const type_list<> &)
template<typename Up >
type_list &	plus (type_list<> &lhs, Up &&)
template<typename Up >
type_list &	minus (type_list<> &lhs, Up &&)
template<typename Up >
type_list &	multiply (type_list<> &lhs, Up &&)
template<typename Up >
type_list &	divide (type_list<> &lhs, Up &&)
type_list &	divide (type_list<> &lhs, uint64_t)
type_list &	divide (type_list<> &lhs, int64_t)
template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>
Tp	max (Tp _lhs, Tp _rhs, type_list<>)
template<typename Tp , typename Vp = typename Tp::value_type>
auto	max (const Tp &_lhs, const Tp &_rhs, type_list<>,...) -> decltype(std::begin(_lhs), Tp{})
template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>
auto	max (const Tp &_lhs, const Tp &_rhs, type_list<>) -> decltype(std::begin(_lhs), Tp{})
template<typename Tp , size_t... Idx>
auto	max (const Tp &_lhs, const Tp &_rhs, index_sequence< Idx... >) -> decltype(std::get< 0 >(_lhs), Tp{})
template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>
Tp	min (Tp _lhs, Tp _rhs, type_list<>)
template<typename Tp , typename Vp = typename Tp::value_type>
auto	min (const Tp &_lhs, const Tp &_rhs, type_list<>,...) -> decltype(std::begin(_lhs), Tp{})
template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>
auto	min (const Tp &_lhs, const Tp &_rhs, type_list<>) -> decltype(std::begin(_lhs), Tp{})
template<typename Tp , size_t... Idx>
auto	min (const Tp &_lhs, const Tp &_rhs, index_sequence< Idx... >) -> decltype(std::get< 0 >(_lhs), Tp{})
template<typename Tp , typename Up >
auto	minus (Tp &_lhs, const Up &_rhs, type_list<>,...) -> decltype(_lhs -=_rhs, void())
template<typename Tp , typename Up , typename Vp = typename Tp::value_type>
auto	minus (Tp &_lhs, const Up &_rhs, type_list<>, long) -> decltype(std::begin(_lhs), void())
template<typename Tp , typename Up , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>
auto	minus (Tp &_lhs, const Up &_rhs, type_list<>, int) -> decltype(std::begin(_lhs), void())
template<typename Tp , typename Up >
auto	minus (Tp &, const Up &, index_sequence<>, int)
template<typename Tp , typename Up , size_t... Idx>
auto	minus (Tp &_lhs, const Up &_rhs, index_sequence< Idx... >, long) -> decltype(std::get< 0 >(_lhs), void())
template<typename Tp , typename Up >
auto	multiply (Tp &_lhs, Up _rhs, type_list<>,...) -> decltype(_lhs *=_rhs, void())
template<typename Tp , typename Up , typename Vp = typename Tp::value_type>
auto	multiply (Tp &_lhs, const Up &_rhs, type_list<>, long) -> decltype((std::begin(_lhs), std::begin(_rhs)), void())
template<typename Tp , typename Up , typename Vp = typename Tp::value_type, enable_if_t< std::is_arithmetic< Up >::value > = 0>
auto	multiply (Tp &_lhs, const Up &_rhs, type_list<>, long) -> decltype(std::begin(_lhs), void())
template<typename Tp , typename Up , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type, enable_if_t<!std::is_arithmetic< Up >::value > = 0>
auto	multiply (Tp &_lhs, const Up &_rhs, type_list<>, int) -> decltype(std::begin(_lhs), void())
template<typename Tp , typename Up >
auto	multiply (Tp &, const Up &, index_sequence<>, int)
template<typename Tp , typename Up , size_t... Idx, enable_if_t<!std::is_arithmetic< Up >::value > = 0>
auto	multiply (Tp &_lhs, const Up &_rhs, index_sequence< Idx... >, long) -> decltype(std::get< 0 >(_lhs), void())
template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>
Tp	percent_diff (Tp _lhs, Tp _rhs, type_list<>,...)
template<typename Tp , enable_if_t<!std::is_arithmetic< Tp >::value &&std::is_class< Tp >::value > = 0>
auto	percent_diff (Tp _lhs, Tp _rhs, type_list<>,...) -> decltype(_lhs.percent_diff(_rhs))
template<typename Tp , typename Vp = typename Tp::value_type>
auto	percent_diff (const Tp &_lhs, const Tp &_rhs, type_list<>, long) -> decltype(std::begin(_lhs), Tp{})
template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>
auto	percent_diff (const Tp &_lhs, const Tp &_rhs, type_list<>, int) -> decltype(std::begin(_lhs), Tp{})
template<typename Tp , size_t... Idx>
auto	percent_diff (const Tp &_lhs, const Tp &_rhs, index_sequence< Idx... >,...) -> decltype(std::get< 0 >(_lhs), Tp{})
template<typename Tp , typename Up >
auto	plus (Tp &_lhs, const Up &_rhs, type_list<>,...) -> decltype(_lhs+=_rhs, void())
template<typename Tp , typename Up , typename Vp = typename Tp::value_type>
auto	plus (Tp &_lhs, const Up &_rhs, type_list<>, long) -> decltype(std::begin(_lhs), void())
template<typename Tp , typename Up , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>
auto	plus (Tp &_lhs, const Up &_rhs, type_list<>, int) -> decltype(std::begin(_lhs), void())
template<typename Tp , typename Up >
auto	plus (Tp &, const Up &, index_sequence<>, int)
template<typename Tp , typename Up , size_t... Idx>
auto	plus (Tp &_lhs, const Up &_rhs, index_sequence< Idx... >, long) -> decltype(std::get< 0 >(_lhs), void())
template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>
auto	pow (Tp _val, double _m, type_list<>) -> decltype(std::pow(_val, _m), Tp{})
template<typename Tp , typename Vp = typename Tp::value_type>
auto	pow (Tp _val, double _m, type_list<>,...) -> decltype(std::begin(_val), Tp{})
template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>
auto	pow (Tp _val, double _m, type_list<>) -> decltype(std::begin(_val), Tp{})
template<template< typename... > class Tuple, typename... Types, size_t... Idx>
auto	pow (Tuple< Types... > _val, double _m, index_sequence< Idx... >) -> decltype(std::get< 0 >(_val), Tuple< Types... >())
template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>
auto	sqrt (Tp _val, type_list<>) -> decltype(std::sqrt(_val), Tp{})
template<typename Tp , typename Vp = typename Tp::value_type>
auto	sqrt (Tp _val, type_list<>,...) -> decltype(std::begin(_val), Tp{})
template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>
auto	sqrt (Tp _val, type_list<>) -> decltype(std::begin(_val), Tp{})
template<template< typename... > class Tuple, typename... Types, size_t... Idx>
auto	sqrt (Tuple< Types... > _val, index_sequence< Idx... >) -> decltype(std::get< 0 >(_val), Tuple< Types... >())

Variables
type_list	abs (type_list<>)
type_list	sqrt (type_list<>)
type_list	sqr (type_list<>)

Function Documentation

abs() [1/6]

null_type tim::math::abs

(

null_type

)

Definition at line 404 of file fwd.hpp.

{

abs() [2/6]

std::tuple tim::math::abs

(

std::tuple<>

)

Definition at line 403 of file fwd.hpp.

{

abs() [3/6]

template<typename Tp >

Tp tim::math::abs

(

Tp

_val

)

Definition at line 89 of file abs.hpp.

{
    return ::tim::math::abs(_val, get_index_sequence<Tp>::value);
}

References abs().

Referenced by abs().

abs() [4/6]

template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0, enable_if_t< std::is_integral< Tp >::value &&std::is_unsigned< Tp >::value > = 0>

auto tim::math::abs	(	Tp	_val,
		type_list<>
	)		-> decltype(Tp{})

Definition at line 44 of file abs.hpp.

                                        {})
{
    return _val;
}

abs() [5/6]

template<typename Tp , typename Vp = typename Tp::value_type>

auto tim::math::abs	(	Tp	_val,
		type_list<>	,
			...
	)		-> decltype(std::begin(_val), Tp{})

Definition at line 59 of file abs.hpp.

                                                             {})
{
    for(auto& itr : _val)
        itr = ::tim::math::abs(itr);
    return _val;
}

abs() [6/6]

template<template< typename... > class Tuple, typename... Types, size_t... Idx>

auto tim::math::abs	(	Tuple< Types... >	_val,
		index_sequence< Idx... >
	)		-> decltype(std::get<0>(_val), Tuple<Types...>())

Definition at line 80 of file abs.hpp.

{
    TIMEMORY_FOLD_EXPRESSION(std::get<Idx>(_val) = ::tim::math::abs(std::get<Idx>(_val)));
    return _val;
}

References abs, and TIMEMORY_FOLD_EXPRESSION.

assign() [1/4]

void tim::math::assign	(	null_type &	,
		null_type &&
	)

Definition at line 404 of file fwd.hpp.

{

assign() [2/4]

void tim::math::assign	(	std::tuple<> &	,
		std::tuple<> &&
	)

Definition at line 403 of file fwd.hpp.

{

assign() [3/4]

template<typename Tp , typename Up >

void tim::math::assign	(	Tp &	_lhs,
		Up &&	_rhs
	)

Definition at line 43 of file assign.hpp.

{
    _lhs = std::forward<Up>(_rhs);
}

assign() [4/4]

void tim::math::assign	(	type_list<> &	,
		type_list<> &&
	)

Definition at line 405 of file fwd.hpp.

{

divide() [1/18]

null_type & tim::math::divide	(	null_type &	lhs,
		const null_type &
	)

Definition at line 404 of file fwd.hpp.

{

divide() [2/18]

null_type & tim::math::divide	(	null_type &	lhs,
		int64_t
	)

Definition at line 404 of file fwd.hpp.

{

divide() [3/18]

null_type & tim::math::divide	(	null_type &	lhs,
		uint64_t
	)

Definition at line 404 of file fwd.hpp.

{

divide() [4/18]

template<typename Up >

null_type & tim::math::divide	(	null_type &	lhs,
		Up &&
	)

Definition at line 404 of file fwd.hpp.

{

divide() [5/18]

std::tuple & tim::math::divide	(	std::tuple<> &	lhs,
		const std::tuple<> &
	)

Definition at line 403 of file fwd.hpp.

{

divide() [6/18]

std::tuple & tim::math::divide	(	std::tuple<> &	lhs,
		int64_t
	)

Definition at line 403 of file fwd.hpp.

{

divide() [7/18]

std::tuple & tim::math::divide	(	std::tuple<> &	lhs,
		uint64_t
	)

Definition at line 403 of file fwd.hpp.

{

divide() [8/18]

template<typename Up >

std::tuple & tim::math::divide	(	std::tuple<> &	lhs,
		Up &&
	)

Definition at line 403 of file fwd.hpp.

{

divide() [9/18]

template<typename Tp , typename Up >

auto tim::math::divide	(	Tp &	,
		const Up &	,
		index_sequence<>	,
		int
	)

Definition at line 114 of file divide.hpp.

{}

divide() [10/18]

template<typename Tp , typename Up , enable_if_t<!concepts::is_null_type< Tp >::value > >

Tp & tim::math::divide	(	Tp &	_lhs,
		const Up &	_rhs
	)

Definition at line 139 of file divide.hpp.

{
    divide(_lhs, _rhs, get_index_sequence<Tp>::value, 0);
    return _lhs;
}

References divide().

divide() [11/18]

template<typename Tp , typename Up , size_t... Idx, enable_if_t<!std::is_arithmetic< Up >::value > = 0>

auto tim::math::divide	(	Tp &	_lhs,
		const Up &	_rhs,
		index_sequence< Idx... >	,
		long
	)		-> decltype(std::get<0>(_lhs), void())

Definition at line 120 of file divide.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    TIMEMORY_FOLD_EXPRESSION(divide(std::get<Idx>(_lhs), std::get<Idx>(_rhs)));
}

References divide(), and TIMEMORY_FOLD_EXPRESSION.

divide() [12/18]

template<typename Tp , typename Up , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type, enable_if_t<!std::is_arithmetic< Up >::value > = 0>

auto tim::math::divide	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		int
	)		-> decltype(std::begin(_lhs), void())

Definition at line 85 of file divide.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
 
    for(auto litr = std::begin(_lhs); litr != std::end(_lhs); ++litr)
    {
        auto ritr = _rhs.find(litr->first);
        if(ritr == std::end(_rhs))
            continue;
        divide(litr->second, ritr->second);
    }
}

References divide().

divide() [13/18]

template<typename Tp , typename Up , typename Vp = typename Tp::value_type, enable_if_t<!std::is_arithmetic< Up >::value > = 0>

auto tim::math::divide	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		long
	)		-> decltype(std::begin(_lhs), void())

Definition at line 52 of file divide.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _n = mpl::get_size(_rhs);
    if(mpl::get_size(_lhs) < _n)
        mpl::resize(_lhs, _n);
 
    for(decltype(_n) i = 0; i < _n; ++i)
    {
        auto litr = std::begin(_lhs) + i;
        auto ritr = std::begin(_rhs) + i;
        divide(*litr, *ritr);
    }
}

References divide(), tim::mpl::get_size(), and tim::mpl::resize().

divide() [14/18]

template<typename Tp , typename Up >

auto tim::math::divide	(	Tp &	_lhs,
		Up	_rhs,
		type_list<>	,
			...
	)		-> decltype(_lhs /= _rhs, void())

Definition at line 43 of file divide.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    _lhs /= _rhs;
}

Referenced by divide(), tim::component::data_tracker< InpT, Tag >::mark_begin(), tim::component::data_tracker< InpT, Tag >::mark_end(), and tim::component::data_tracker< InpT, Tag >::store().

divide() [15/18]

type_list & tim::math::divide	(	type_list<> &	lhs,
		const type_list<> &
	)

Definition at line 405 of file fwd.hpp.

{

divide() [16/18]

type_list & tim::math::divide	(	type_list<> &	lhs,
		int64_t
	)

Definition at line 405 of file fwd.hpp.

{

divide() [17/18]

type_list & tim::math::divide	(	type_list<> &	lhs,
		uint64_t
	)

Definition at line 405 of file fwd.hpp.

{

divide() [18/18]

template<typename Up >

type_list & tim::math::divide	(	type_list<> &	lhs,
		Up &&
	)

Definition at line 405 of file fwd.hpp.

{

is_finite()

template<typename Tp >

bool tim::math::is_finite

(

const Tp &

val

)

Definition at line 42 of file fwd.hpp.

{
#if defined(TIMEMORY_WINDOWS)
    const Tp _infv = std::numeric_limits<Tp>::infinity();
    const Tp _inf  = (val < 0.0) ? -_infv : _infv;
    return (val == val && val != _inf);
#else
    return std::isfinite(val);
#endif
}

References tim::isfinite().

max() [1/8]

null_type tim::math::max	(	const null_type &	,
		const null_type &
	)

Definition at line 404 of file fwd.hpp.

{

max() [2/8]

std::tuple tim::math::max	(	const std::tuple<> &	,
		const std::tuple<> &
	)

Definition at line 403 of file fwd.hpp.

{

max() [3/8]

template<typename Tp >

Tp tim::math::max	(	const Tp &	_lhs,
		const Tp &	_rhs
	)

Definition at line 112 of file max.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    return max(_lhs, _rhs, get_index_sequence<Tp>::value);
}

References max().

Referenced by max().

max() [4/8]

template<typename Tp , size_t... Idx>

auto tim::math::max	(	const Tp &	_lhs,
		const Tp &	_rhs,
		index_sequence< Idx... >
	)		-> decltype(std::get<0>(_lhs), Tp{})

Definition at line 100 of file max.hpp.

                                   {})
{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    Tp _ret{};
    TIMEMORY_FOLD_EXPRESSION(
        std::get<Idx>(_ret) = ::tim::math::max(std::get<Idx>(_lhs), std::get<Idx>(_rhs)));
    return _ret;
}

max() [5/8]

template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>

auto tim::math::max	(	const Tp &	_lhs,
		const Tp &	_rhs,
		type_list<>
	)		-> decltype(std::begin(_lhs), Tp{})

Definition at line 76 of file max.hpp.

                                                                               {})
{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _nl    = mpl::get_size(_lhs);
    auto _nr    = mpl::get_size(_rhs);
    using Int_t = decltype(_nl);
    assert(_nl == _nr);
 
    auto _n = std::min<Int_t>(_nl, _nr);
    Tp   _ret{};
    mpl::resize(_ret, _n);
 
    for(Int_t i = 0; i < _n; ++i)
    {
        auto litr   = std::begin(_lhs) + i;
        auto ritr   = std::begin(_rhs) + i;
        auto itr    = std::begin(_ret) + i;
        itr->second = ::tim::math::max(litr->second, ritr->second);
    }
    return _ret;
}

max() [6/8]

template<typename Tp , typename Vp = typename Tp::value_type>

auto tim::math::max	(	const Tp &	_lhs,
		const Tp &	_rhs,
		type_list<>	,
			...
	)		-> decltype(std::begin(_lhs), Tp{})

Definition at line 51 of file max.hpp.

                                                                                    {})
{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _nl    = mpl::get_size(_lhs);
    auto _nr    = mpl::get_size(_rhs);
    using Int_t = decltype(_nl);
    assert(_nl == _nr);
 
    auto _n = std::min<Int_t>(_nl, _nr);
    Tp   _ret{};
    mpl::resize(_ret, _n);
 
    for(Int_t i = 0; i < _n; ++i)
    {
        auto litr = std::begin(_lhs) + i;
        auto ritr = std::begin(_rhs) + i;
        auto itr  = std::begin(_ret) + i;
        *itr      = ::tim::math::max(*litr, *ritr);
    }
    return _ret;
}

max() [7/8]

type_list tim::math::max	(	const type_list<> &	,
		const type_list<> &
	)

Definition at line 405 of file fwd.hpp.

{

max() [8/8]

template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>

Tp tim::math::max	(	Tp	_lhs,
		Tp	_rhs,
		type_list<>
	)

Definition at line 43 of file max.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    return (_rhs < _lhs) ? _lhs : _rhs;
}

min() [1/8]

null_type tim::math::min	(	const null_type &	,
		const null_type &
	)

Definition at line 404 of file fwd.hpp.

{

min() [2/8]

std::tuple tim::math::min	(	const std::tuple<> &	,
		const std::tuple<> &
	)

Definition at line 403 of file fwd.hpp.

{

min() [3/8]

template<typename Tp >

Tp tim::math::min	(	const Tp &	_lhs,
		const Tp &	_rhs
	)

Definition at line 112 of file min.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    return min(_lhs, _rhs, get_index_sequence<Tp>::value);
}

References min().

Referenced by min().

min() [4/8]

template<typename Tp , size_t... Idx>

auto tim::math::min	(	const Tp &	_lhs,
		const Tp &	_rhs,
		index_sequence< Idx... >
	)		-> decltype(std::get<0>(_lhs), Tp{})

Definition at line 100 of file min.hpp.

                                   {})
{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    Tp _ret{};
    TIMEMORY_FOLD_EXPRESSION(
        std::get<Idx>(_ret) = ::tim::math::min(std::get<Idx>(_lhs), std::get<Idx>(_rhs)));
    return _ret;
}

min() [5/8]

template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>

auto tim::math::min	(	const Tp &	_lhs,
		const Tp &	_rhs,
		type_list<>
	)		-> decltype(std::begin(_lhs), Tp{})

Definition at line 76 of file min.hpp.

                                                                               {})
{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _nl    = mpl::get_size(_lhs);
    auto _nr    = mpl::get_size(_rhs);
    using Int_t = decltype(_nl);
    assert(_nl == _nr);
 
    auto _n = std::min<Int_t>(_nl, _nr);
    Tp   _ret{};
    mpl::resize(_ret, _n);
 
    for(Int_t i = 0; i < _n; ++i)
    {
        auto litr   = std::begin(_lhs) + i;
        auto ritr   = std::begin(_rhs) + i;
        auto itr    = std::begin(_ret) + i;
        itr->second = ::tim::math::min(litr->second, ritr->second);
    }
    return _ret;
}

min() [6/8]

template<typename Tp , typename Vp = typename Tp::value_type>

auto tim::math::min	(	const Tp &	_lhs,
		const Tp &	_rhs,
		type_list<>	,
			...
	)		-> decltype(std::begin(_lhs), Tp{})

Definition at line 51 of file min.hpp.

                                                                                    {})
{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _nl    = mpl::get_size(_lhs);
    auto _nr    = mpl::get_size(_rhs);
    using Int_t = decltype(_nl);
    assert(_nl == _nr);
 
    auto _n = std::min<Int_t>(_nl, _nr);
    Tp   _ret{};
    mpl::resize(_ret, _n);
 
    for(Int_t i = 0; i < _n; ++i)
    {
        auto litr = std::begin(_lhs) + i;
        auto ritr = std::begin(_rhs) + i;
        auto itr  = std::begin(_ret) + i;
        *itr      = ::tim::math::min(*litr, *ritr);
    }
    return _ret;
}

min() [7/8]

type_list tim::math::min	(	const type_list<> &	,
		const type_list<> &
	)

Definition at line 405 of file fwd.hpp.

{

min() [8/8]

template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>

Tp tim::math::min	(	Tp	_lhs,
		Tp	_rhs,
		type_list<>
	)

Definition at line 43 of file min.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    return (_rhs > _lhs) ? _lhs : _rhs;
}

minus() [1/12]

null_type & tim::math::minus	(	null_type &	lhs,
		const null_type &
	)

Definition at line 404 of file fwd.hpp.

{

minus() [2/12]

template<typename Up >

null_type & tim::math::minus	(	null_type &	lhs,
		Up &&
	)

Definition at line 404 of file fwd.hpp.

{

minus() [3/12]

std::tuple & tim::math::minus	(	std::tuple<> &	lhs,
		const std::tuple<> &
	)

Definition at line 403 of file fwd.hpp.

{

minus() [4/12]

template<typename Up >

std::tuple & tim::math::minus	(	std::tuple<> &	lhs,
		Up &&
	)

Definition at line 403 of file fwd.hpp.

{

minus() [5/12]

template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>

Tp & tim::math::minus	(	Tp &	_lhs,
		const Up &	_rhs
	)

Definition at line 98 of file minus.hpp.

{
    minus(_lhs, _rhs, get_index_sequence<Tp>::value, 0);
    return _lhs;
}

References minus().

Referenced by tim::data::handler< V, Tag >::end(), minus(), tim::mpl::apply< void >::minus(), and tim::component::operators::operator-().

minus() [6/12]

template<typename Tp , typename Up >

auto tim::math::minus	(	Tp &	,
		const Up &	,
		index_sequence<>	,
		int
	)

Definition at line 84 of file minus.hpp.

{}

minus() [7/12]

template<typename Tp , typename Up , size_t... Idx>

auto tim::math::minus	(	Tp &	_lhs,
		const Up &	_rhs,
		index_sequence< Idx... >	,
		long
	)		-> decltype(std::get<0>(_lhs), void())

Definition at line 89 of file minus.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    TIMEMORY_FOLD_EXPRESSION(minus(std::get<Idx>(_lhs), std::get<Idx>(_rhs)));
}

References minus(), and TIMEMORY_FOLD_EXPRESSION.

minus() [8/12]

template<typename Tp , typename Up , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>

auto tim::math::minus	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		int
	)		-> decltype(std::begin(_lhs), void())

Definition at line 69 of file minus.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
 
    for(auto litr = std::begin(_lhs); litr != std::end(_lhs); ++litr)
    {
        auto ritr = _rhs.find(litr->first);
        if(ritr == std::end(_rhs))
            continue;
        minus(litr->second, ritr->second);
    }
}

References minus().

minus() [9/12]

template<typename Tp , typename Up , typename Vp = typename Tp::value_type>

auto tim::math::minus	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		long
	)		-> decltype(std::begin(_lhs), void())

Definition at line 51 of file minus.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _n = mpl::get_size(_rhs);
    if(mpl::get_size(_lhs) < _n)
        mpl::resize(_lhs, _n);
 
    for(decltype(_n) i = 0; i < _n; ++i)
    {
        auto litr = std::begin(_lhs) + i;
        auto ritr = std::begin(_rhs) + i;
        minus(*litr, *ritr);
    }
}

References tim::mpl::get_size(), minus(), and tim::mpl::resize().

minus() [10/12]

template<typename Tp , typename Up >

auto tim::math::minus	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
			...
	)		-> decltype(_lhs -= _rhs, void())

Definition at line 43 of file minus.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    _lhs -= _rhs;
}

minus() [11/12]

type_list & tim::math::minus	(	type_list<> &	lhs,
		const type_list<> &
	)

Definition at line 405 of file fwd.hpp.

{

minus() [12/12]

template<typename Up >

type_list & tim::math::minus	(	type_list<> &	lhs,
		Up &&
	)

Definition at line 405 of file fwd.hpp.

{

multiply() [1/13]

null_type & tim::math::multiply	(	null_type &	lhs,
		const null_type &
	)

Definition at line 404 of file fwd.hpp.

{

multiply() [2/13]

template<typename Up >

null_type & tim::math::multiply	(	null_type &	lhs,
		Up &&
	)

Definition at line 404 of file fwd.hpp.

{

multiply() [3/13]

std::tuple & tim::math::multiply	(	std::tuple<> &	lhs,
		const std::tuple<> &
	)

Definition at line 403 of file fwd.hpp.

{

multiply() [4/13]

template<typename Up >

std::tuple & tim::math::multiply	(	std::tuple<> &	lhs,
		Up &&
	)

Definition at line 403 of file fwd.hpp.

{

multiply() [5/13]

template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>

Tp & tim::math::multiply	(	Tp &	_lhs,
		const Up &	_rhs
	)

Definition at line 140 of file multiply.hpp.

{
    multiply(_lhs, _rhs, get_index_sequence<Tp>::value, 0);
    return _lhs;
}

References multiply().

Referenced by multiply().

multiply() [6/13]

template<typename Tp , typename Up >

auto tim::math::multiply	(	Tp &	,
		const Up &	,
		index_sequence<>	,
		int
	)

Definition at line 115 of file multiply.hpp.

{}

multiply() [7/13]

template<typename Tp , typename Up , size_t... Idx, enable_if_t<!std::is_arithmetic< Up >::value > = 0>

auto tim::math::multiply	(	Tp &	_lhs,
		const Up &	_rhs,
		index_sequence< Idx... >	,
		long
	)		-> decltype(std::get<0>(_lhs), void())

Definition at line 121 of file multiply.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    TIMEMORY_FOLD_EXPRESSION(multiply(std::get<Idx>(_lhs), std::get<Idx>(_rhs)));
}

References multiply(), and TIMEMORY_FOLD_EXPRESSION.

multiply() [8/13]

template<typename Tp , typename Up , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type, enable_if_t<!std::is_arithmetic< Up >::value > = 0>

auto tim::math::multiply	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		int
	)		-> decltype(std::begin(_lhs), void())

Definition at line 86 of file multiply.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
 
    for(auto litr = std::begin(_lhs); litr != std::end(_lhs); ++litr)
    {
        auto ritr = _rhs.find(litr->first);
        if(ritr == std::end(_rhs))
            continue;
        multiply(litr->second, ritr->second);
    }
}

References multiply().

multiply() [9/13]

template<typename Tp , typename Up , typename Vp = typename Tp::value_type>

auto tim::math::multiply	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		long
	)		-> decltype((std::begin(_lhs), std::begin(_rhs)), void())

Definition at line 51 of file multiply.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _n = mpl::get_size(_rhs);
    if(mpl::get_size(_lhs) < _n)
        mpl::resize(_lhs, _n);
 
    for(decltype(_n) i = 0; i < _n; ++i)
    {
        auto litr = std::begin(_lhs) + i;
        auto ritr = std::begin(_rhs) + i;
        multiply(*litr, *ritr);
    }
}

References tim::mpl::get_size(), multiply(), and tim::mpl::resize().

multiply() [10/13]

template<typename Tp , typename Up , typename Vp = typename Tp::value_type, enable_if_t< std::is_arithmetic< Up >::value > = 0>

auto tim::math::multiply	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		long
	)		-> decltype(std::begin(_lhs), void())

Definition at line 70 of file multiply.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _n = mpl::get_size(_lhs);
    for(decltype(_n) i = 0; i < _n; ++i)
    {
        auto litr = std::begin(_lhs) + i;
        multiply(*litr, _rhs);
    }
}

References tim::mpl::get_size(), and multiply().

multiply() [11/13]

template<typename Tp , typename Up >

auto tim::math::multiply	(	Tp &	_lhs,
		Up	_rhs,
		type_list<>	,
			...
	)		-> decltype(_lhs *= _rhs, void())

Definition at line 43 of file multiply.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    _lhs *= _rhs;
}

multiply() [12/13]

type_list & tim::math::multiply	(	type_list<> &	lhs,
		const type_list<> &
	)

Definition at line 405 of file fwd.hpp.

{

multiply() [13/13]

template<typename Up >

type_list & tim::math::multiply	(	type_list<> &	lhs,
		Up &&
	)

Definition at line 405 of file fwd.hpp.

{

percent_diff() [1/9]

null_type tim::math::percent_diff	(	const null_type &	,
		const null_type &
	)

Definition at line 404 of file fwd.hpp.

{

percent_diff() [2/9]

std::tuple tim::math::percent_diff	(	const std::tuple<> &	,
		const std::tuple<> &
	)

Definition at line 403 of file fwd.hpp.

{

percent_diff() [3/9]

template<typename Tp >

Tp tim::math::percent_diff	(	const Tp &	_lhs,
		const Tp &	_rhs
	)

Definition at line 124 of file percent_diff.hpp.

{
    return percent_diff(_lhs, _rhs, get_index_sequence<Tp>::value, 0);
}

References percent_diff().

Referenced by percent_diff(), and tim::operation::finalize::print< Tp, true >::write_stream().

percent_diff() [4/9]

template<typename Tp , size_t... Idx>

auto tim::math::percent_diff	(	const Tp &	_lhs,
		const Tp &	_rhs,
		index_sequence< Idx... >	,
			...
	)		-> decltype(std::get<0>(_lhs), Tp{})

Definition at line 113 of file percent_diff.hpp.

                                   {})
{
    Tp _ret{};
    TIMEMORY_FOLD_EXPRESSION(std::get<Idx>(_ret) =
                                 percent_diff(std::get<Idx>(_lhs), std::get<Idx>(_rhs)));
    return _ret;
}

percent_diff() [5/9]

template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>

auto tim::math::percent_diff	(	const Tp &	_lhs,
		const Tp &	_rhs,
		type_list<>	,
		int
	)		-> decltype(std::begin(_lhs), Tp{})

Definition at line 91 of file percent_diff.hpp.

                                  {})
{
    assert(_lhs.size() == _rhs.size());
    Tp _ret{};
    for(auto litr = std::begin(_lhs); litr != std::end(_lhs); ++litr)
    {
        auto ritr = _rhs.find(litr->first);
        if(ritr == std::end(_rhs))
        {
            _ret[litr->first] = Mp{};
        }
        else
        {
            _ret[litr->first] = percent_diff(litr->second, ritr->second);
        }
    }
    return _ret;
}

percent_diff() [6/9]

template<typename Tp , typename Vp = typename Tp::value_type>

auto tim::math::percent_diff	(	const Tp &	_lhs,
		const Tp &	_rhs,
		type_list<>	,
		long
	)		-> decltype(std::begin(_lhs), Tp{})

Definition at line 62 of file percent_diff.hpp.

                                  {})
{
    auto _nl    = mpl::get_size(_lhs);
    auto _nr    = mpl::get_size(_rhs);
    using Int_t = decltype(_nl);
 
    auto _n = std::min<Int_t>(_nl, _nr);
    Tp   _ret{};
    mpl::resize(_ret, _n);
 
    // initialize
    for(auto& itr : _ret)
        itr = Vp{};
 
    // compute
    for(Int_t i = 0; i < _n; ++i)
    {
        auto litr = std::begin(_lhs) + i;
        auto ritr = std::begin(_rhs) + i;
        auto itr  = std::begin(_ret) + i;
        *itr      = percent_diff(*litr, *ritr);
    }
    return _ret;
}

percent_diff() [7/9]

type_list tim::math::percent_diff	(	const type_list<> &	,
		const type_list<> &
	)

Definition at line 405 of file fwd.hpp.

{

percent_diff() [8/9]

template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>

Tp tim::math::percent_diff	(	Tp	_lhs,
		Tp	_rhs,
		type_list<>	,
			...
	)

Definition at line 43 of file percent_diff.hpp.

{
    constexpr Tp _zero    = Tp(0.0);
    constexpr Tp _one     = Tp(1.0);
    constexpr Tp _hundred = Tp(100.0);
    Tp&&         _pdiff   = (_rhs > _zero) ? ((_one - (_lhs / _rhs)) * _hundred) : _zero;
    return (_pdiff < _zero) ? _zero : _pdiff;
}

percent_diff() [9/9]

template<typename Tp , enable_if_t<!std::is_arithmetic< Tp >::value &&std::is_class< Tp >::value > = 0>

auto tim::math::percent_diff	(	Tp	_lhs,
		Tp	_rhs,
		type_list<>	,
			...
	)		-> decltype(_lhs.percent_diff(_rhs))

Definition at line 55 of file percent_diff.hpp.

{
    return _lhs.percent_diff(_rhs);
}

plus() [1/12]

null_type & tim::math::plus	(	null_type &	lhs,
		const null_type &
	)

Definition at line 404 of file fwd.hpp.

{

plus() [2/12]

template<typename Up >

null_type & tim::math::plus	(	null_type &	lhs,
		Up &&
	)

Definition at line 404 of file fwd.hpp.

{

plus() [3/12]

std::tuple & tim::math::plus	(	std::tuple<> &	lhs,
		const std::tuple<> &
	)

Definition at line 403 of file fwd.hpp.

{

plus() [4/12]

template<typename Up >

std::tuple & tim::math::plus	(	std::tuple<> &	lhs,
		Up &&
	)

Definition at line 403 of file fwd.hpp.

{

plus() [5/12]

template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>

Tp & tim::math::plus	(	Tp &	_lhs,
		const Up &	_rhs
	)

Definition at line 106 of file plus.hpp.

{
    plus(_lhs, _rhs, get_index_sequence<Tp>::value, 0);
    return _lhs;
}

References plus().

Referenced by plus(), tim::mpl::apply< void >::plus(), and tim::operation::finalize::print< Tp, true >::write_stream().

plus() [6/12]

template<typename Tp , typename Up >

auto tim::math::plus	(	Tp &	,
		const Up &	,
		index_sequence<>	,
		int
	)

Definition at line 92 of file plus.hpp.

{}

plus() [7/12]

template<typename Tp , typename Up , size_t... Idx>

auto tim::math::plus	(	Tp &	_lhs,
		const Up &	_rhs,
		index_sequence< Idx... >	,
		long
	)		-> decltype(std::get<0>(_lhs), void())

Definition at line 97 of file plus.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    TIMEMORY_FOLD_EXPRESSION(plus(std::get<Idx>(_lhs), std::get<Idx>(_rhs)));
}

References plus(), and TIMEMORY_FOLD_EXPRESSION.

plus() [8/12]

template<typename Tp , typename Up , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>

auto tim::math::plus	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		int
	)		-> decltype(std::begin(_lhs), void())

Definition at line 69 of file plus.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
 
    for(auto litr = std::begin(_lhs); litr != std::end(_lhs); ++litr)
    {
        auto ritr = _rhs.find(litr->first);
        if(ritr == std::end(_rhs))
            continue;
        plus(litr->second, ritr->second);
    }
 
    for(auto ritr = std::begin(_rhs); ritr != std::end(_rhs); ++ritr)
    {
        auto litr = _lhs.find(ritr->first);
        if(litr == std::end(_lhs))
            continue;
        _lhs[ritr->first] = ritr->second;
    }
}

References plus().

plus() [9/12]

template<typename Tp , typename Up , typename Vp = typename Tp::value_type>

auto tim::math::plus	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
		long
	)		-> decltype(std::begin(_lhs), void())

Definition at line 51 of file plus.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    auto _n = mpl::get_size(_rhs);
    if(mpl::get_size(_lhs) < _n)
        mpl::resize(_lhs, _n);
 
    for(decltype(_n) i = 0; i < _n; ++i)
    {
        auto litr = std::begin(_lhs) + i;
        auto ritr = std::begin(_rhs) + i;
        plus(*litr, *ritr);
    }
}

References tim::mpl::get_size(), plus(), and tim::mpl::resize().

plus() [10/12]

template<typename Tp , typename Up >

auto tim::math::plus	(	Tp &	_lhs,
		const Up &	_rhs,
		type_list<>	,
			...
	)		-> decltype(_lhs += _rhs, void())

Definition at line 43 of file plus.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    _lhs += _rhs;
}

plus() [11/12]

type_list & tim::math::plus	(	type_list<> &	lhs,
		const type_list<> &
	)

Definition at line 405 of file fwd.hpp.

{

plus() [12/12]

template<typename Up >

type_list & tim::math::plus	(	type_list<> &	lhs,
		Up &&
	)

Definition at line 405 of file fwd.hpp.

{

pow() [1/8]

null_type tim::math::pow	(	null_type	,
		double
	)

Definition at line 404 of file fwd.hpp.

{

pow() [2/8]

std::tuple tim::math::pow	(	std::tuple<>	,
		double
	)

Definition at line 403 of file fwd.hpp.

{

pow() [3/8]

template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>

auto tim::math::pow	(	Tp	_val,
		double	_m,
		type_list<>
	)		-> decltype(std::begin(_val), Tp{})

Definition at line 62 of file pow.hpp.

                                                                   {})
{
    for(auto& itr : _val)
    {
        itr.second = ::tim::math::pow(itr.second, _m);
    }
    return _val;
}

pow() [4/8]

template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>

auto tim::math::pow	(	Tp	_val,
		double	_m,
		type_list<>
	)		-> decltype(std::pow(_val, _m), Tp{})

Definition at line 43 of file pow.hpp.

                                                                     {})
{
    return std::pow(_val, _m);
}

pow() [5/8]

template<typename Tp , typename Vp = typename Tp::value_type>

auto tim::math::pow	(	Tp	_val,
		double	_m,
		type_list<>	,
			...
	)		-> decltype(std::begin(_val), Tp{})

Definition at line 50 of file pow.hpp.

                                                                        {})
{
    for(auto& itr : _val)
    {
        itr = ::tim::math::pow(itr, _m);
    }
    return _val;
}

pow() [6/8]

template<typename Tp >

Tp tim::math::pow	(	Tp	_val,
		double	_m
	)

Definition at line 83 of file pow.hpp.

{
    return ::tim::math::pow(_val, _m, get_index_sequence<Tp>::value);
}

References pow().

Referenced by pow(), and sqr().

pow() [7/8]

template<template< typename... > class Tuple, typename... Types, size_t... Idx>

auto tim::math::pow	(	Tuple< Types... >	_val,
		double	_m,
		index_sequence< Idx... >
	)		-> decltype(std::get<0>(_val), Tuple<Types...>())

Definition at line 73 of file pow.hpp.

{
    TIMEMORY_FOLD_EXPRESSION(std::get<Idx>(_val) =
                                 ::tim::math::pow(std::get<Idx>(_val), _m));
    return _val;
}

References pow(), and TIMEMORY_FOLD_EXPRESSION.

Referenced by pow().

pow() [8/8]

type_list tim::math::pow	(	type_list<>	,
		double
	)

Definition at line 405 of file fwd.hpp.

{

sqr() [1/3]

null_type tim::math::sqr

(

null_type

)

Definition at line 404 of file fwd.hpp.

{

sqr() [2/3]

std::tuple tim::math::sqr

(

std::tuple<>

)

Definition at line 403 of file fwd.hpp.

{

sqr() [3/3]

template<typename Tp >

Tp tim::math::sqr

(

Tp

_val

)

Definition at line 43 of file sqr.hpp.

{
    static_assert(!concepts::is_null_type<Tp>::value, "Error! null type");
    return ::tim::math::pow(_val, 2.0);
}

References pow().

sqrt() [1/7]

null_type tim::math::sqrt

(

null_type

)

Definition at line 404 of file fwd.hpp.

{

sqrt() [2/7]

std::tuple tim::math::sqrt

(

std::tuple<>

)

Definition at line 403 of file fwd.hpp.

{

sqrt() [3/7]

template<typename Tp , typename Kp = typename Tp::key_type, typename Mp = typename Tp::mapped_type>

auto tim::math::sqrt	(	Tp	_val,
		type_list<>
	)		-> decltype(std::begin(_val), Tp{})

Definition at line 60 of file sqrt.hpp.

                                                         {})
{
    for(auto& itr : _val)
    {
        itr.second = ::tim::math::sqrt(itr.second);
    }
    return _val;
}

sqrt() [4/7]

template<typename Tp , enable_if_t< std::is_arithmetic< Tp >::value > = 0>

auto tim::math::sqrt	(	Tp	_val,
		type_list<>
	)		-> decltype(std::sqrt(_val), Tp{})

Definition at line 43 of file sqrt.hpp.

                                                        {})
{
    return std::sqrt(_val);
}

sqrt() [5/7]

template<typename Tp , typename Vp = typename Tp::value_type>

auto tim::math::sqrt	(	Tp	_val,
		type_list<>	,
			...
	)		-> decltype(std::begin(_val), Tp{})

Definition at line 50 of file sqrt.hpp.

                                                              {})
{
    for(auto& itr : _val)
        itr = ::tim::math::sqrt(itr);
    return _val;
}

sqrt() [6/7]

template<typename Tp >

Tp tim::math::sqrt

(

Tp

_val

)

Definition at line 81 of file sqrt.hpp.

{
    return ::tim::math::sqrt(_val, get_index_sequence<Tp>::value);
}

References sqrt().

sqrt() [7/7]

template<template< typename... > class Tuple, typename... Types, size_t... Idx>

auto tim::math::sqrt	(	Tuple< Types... >	_val,
		index_sequence< Idx... >
	)		-> decltype(std::get<0>(_val), Tuple<Types...>())

Definition at line 71 of file sqrt.hpp.

{
    TIMEMORY_FOLD_EXPRESSION(std::get<Idx>(_val) =
                                 ::tim::math::sqrt(std::get<Idx>(_val)));
    return _val;
}

References sqrt, and TIMEMORY_FOLD_EXPRESSION.

Referenced by sqrt().

Variable Documentation

abs

type_list tim::math::abs(type_list<>)

(

type_list<>

)

Definition at line 405 of file fwd.hpp.

{

Referenced by abs(), tim::component::read_char::stop(), tim::component::written_char::stop(), tim::component::read_bytes::stop(), and tim::component::written_bytes::stop().

sqr

type_list tim::math::sqr(type_list<>)

(

type_list<>

)

Definition at line 405 of file fwd.hpp.

{

sqrt

type_list tim::math::sqrt(type_list<>)

(

type_list<>

)

Definition at line 405 of file fwd.hpp.

{

Referenced by sqrt().