fwd.hpp File Reference

#include "timemory/mpl/concepts.hpp"
#include "timemory/mpl/types.hpp"
#include "timemory/utility/types.hpp"
#include <cassert>
#include <cmath>
#include <limits>
#include <utility>

Include dependency graph for fwd.hpp:

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

Go to the source code of this file.

Namespaces
namespace	tim
namespace	tim::math
namespace	tim::stl
	the namespace is provided to hide stl overload from global namespace but provide a method of using the namespace without a "using namespace tim;"

Macros
#define	TIMEMORY_MATH_NULL_TYPE_OVERLOAD(TYPE)

Functions
template<typename Tp >
bool	tim::math::is_finite (const Tp &val)
template<typename Tp >
Tp	tim::math::abs (Tp _val)
template<typename Tp >
Tp	tim::math::sqrt (Tp)
template<typename Tp >
Tp	tim::math::pow (Tp, double)
template<typename Tp >
Tp	tim::math::sqr (Tp)
template<typename Tp >
Tp	tim::math::min (const Tp &, const Tp &)
template<typename Tp >
Tp	tim::math::max (const Tp &, const Tp &)
template<typename Tp , typename Up >
void	tim::math::assign (Tp &_lhs, Up &&_rhs)
template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>
Tp &	tim::math::plus (Tp &, const Up &)
template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>
Tp &	tim::math::minus (Tp &, const Up &)
template<typename Tp , typename Up = Tp, enable_if_t<!concepts::is_null_type< Tp >::value > = 0>
Tp &	tim::math::multiply (Tp &, const Up &)
template<typename Tp , typename Up , enable_if_t<!concepts::is_null_type< Tp >::value > >
Tp &	tim::math::divide (Tp &_lhs, const Up &_rhs)
template<typename Tp >
Tp	tim::math::percent_diff (const Tp &, const Tp &)
template<typename Tp , size_t N, typename Other >
std::array< Tp, N > &	tim::stl::operator+= (std::array< Tp, N > &, Other &&)
template<typename Lhs , typename Rhs , typename Other >
std::pair< Lhs, Rhs > &	tim::stl::operator+= (std::pair< Lhs, Rhs > &, Other &&)
template<typename Tp , typename... _Extra, typename Other >
std::vector< Tp, _Extra... > &	tim::stl::operator+= (std::vector< Tp, _Extra... > &, Other &&)
template<typename... Types, typename Other >
std::tuple< Types... > &	tim::stl::operator+= (std::tuple< Types... > &, Other &&)
template<typename Tp , size_t N>
std::array< Tp, N > &	tim::stl::operator-= (std::array< Tp, N > &, const std::array< Tp, N > &)
template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > &	tim::stl::operator-= (std::array< Lhs, N > &, const Rhs &)
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > &	tim::stl::operator-= (std::pair< Lhs, Rhs > &, const std::pair< Lhs, Rhs > &)
template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > &	tim::stl::operator-= (std::pair< Lhs, Rhs > &, const ArithT &)
template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > &	tim::stl::operator-= (std::vector< Tp, _Extra... > &, const std::vector< Tp, _Extra... > &)
template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > &	tim::stl::operator-= (std::vector< Lhs, _Extra... > &, const Rhs &)
template<typename... Types>
std::tuple< Types... > &	tim::stl::operator-= (std::tuple< Types... > &, const std::tuple< Types... > &)
template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > &	tim::stl::operator-= (std::tuple< Lhs... > &, const Rhs &)
template<typename Tp , size_t N>
std::array< Tp, N > &	tim::stl::operator*= (std::array< Tp, N > &, const std::array< Tp, N > &)
template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > &	tim::stl::operator*= (std::array< Lhs, N > &, const Rhs &)
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > &	tim::stl::operator*= (std::pair< Lhs, Rhs > &, const std::pair< Lhs, Rhs > &)
template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > &	tim::stl::operator*= (std::pair< Lhs, Rhs > &, const ArithT &)
template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > &	tim::stl::operator*= (std::vector< Tp, _Extra... > &, const std::vector< Tp, _Extra... > &)
template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > &	tim::stl::operator*= (std::vector< Lhs, _Extra... > &, const Rhs &)
template<typename... Types>
std::tuple< Types... > &	tim::stl::operator*= (std::tuple< Types... > &, const std::tuple< Types... > &)
template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > &	tim::stl::operator*= (std::tuple< Lhs... > &, const Rhs &)
template<typename Tp , size_t N>
std::array< Tp, N > &	tim::stl::operator/= (std::array< Tp, N > &, const std::array< Tp, N > &)
template<typename Lhs , size_t N, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::array< Lhs, N > &	tim::stl::operator/= (std::array< Lhs, N > &, const Rhs &)
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs > &	tim::stl::operator/= (std::pair< Lhs, Rhs > &, const std::pair< Lhs, Rhs > &)
template<typename Lhs , typename Rhs , typename ArithT , enable_if_t< std::is_arithmetic< decay_t< ArithT > >::value, int > = 0>
std::pair< Lhs, Rhs > &	tim::stl::operator/= (std::pair< Lhs, Rhs > &, const ArithT &)
template<typename Tp , typename... _Extra>
std::vector< Tp, _Extra... > &	tim::stl::operator/= (std::vector< Tp, _Extra... > &, const std::vector< Tp, _Extra... > &)
template<typename Lhs , typename Rhs , typename... _Extra, enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::vector< Lhs, _Extra... > &	tim::stl::operator/= (std::vector< Lhs, _Extra... > &, const Rhs &)
template<typename... Types>
std::tuple< Types... > &	tim::stl::operator/= (std::tuple< Types... > &, const std::tuple< Types... > &)
template<typename... Lhs, typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
std::tuple< Lhs... > &	tim::stl::operator/= (std::tuple< Lhs... > &, const Rhs &)
template<typename Lhs , typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
Lhs	tim::stl::operator* (Lhs, const Rhs &)
template<typename Lhs , typename Rhs , enable_if_t< std::is_arithmetic< decay_t< Rhs > >::value, int > = 0>
Lhs	tim::stl::operator/ (Lhs, const Rhs &)
template<typename Tp , size_t N>
std::array< Tp, N >	tim::stl::operator+ (std::array< Tp, N > lhs, const std::array< Tp, N > &rhs)
template<typename... Types>
std::tuple< Types... >	tim::stl::operator+ (std::tuple< Types... > lhs, const std::tuple< Types... > &rhs)
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs >	tim::stl::operator+ (std::pair< Lhs, Rhs > lhs, const std::pair< Lhs, Rhs > &rhs)
template<typename Tp , typename... Extra>
std::vector< Tp, Extra... >	tim::stl::operator+ (std::vector< Tp, Extra... > lhs, const std::vector< Tp, Extra... > &rhs)
template<typename Tp , size_t N>
std::array< Tp, N >	tim::stl::operator- (std::array< Tp, N > lhs, const std::array< Tp, N > &rhs)
template<typename... Types>
std::tuple< Types... >	tim::stl::operator- (std::tuple< Types... > lhs, const std::tuple< Types... > &rhs)
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs >	tim::stl::operator- (std::pair< Lhs, Rhs > lhs, const std::pair< Lhs, Rhs > &rhs)
template<typename Tp , typename... Extra>
std::vector< Tp, Extra... >	tim::stl::operator- (std::vector< Tp, Extra... > lhs, const std::vector< Tp, Extra... > &rhs)
template<typename Tp , size_t N>
std::array< Tp, N >	tim::stl::operator* (std::array< Tp, N > lhs, const std::array< Tp, N > &rhs)
template<typename... Types>
std::tuple< Types... >	tim::stl::operator* (std::tuple< Types... > lhs, const std::tuple< Types... > &rhs)
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs >	tim::stl::operator* (std::pair< Lhs, Rhs > lhs, const std::pair< Lhs, Rhs > &rhs)
template<typename Tp , typename... Extra>
std::vector< Tp, Extra... >	tim::stl::operator* (std::vector< Tp, Extra... > lhs, const std::vector< Tp, Extra... > &rhs)
template<typename Tp , size_t N>
std::array< Tp, N >	tim::stl::operator/ (std::array< Tp, N > lhs, const std::array< Tp, N > &rhs)
template<typename... Types>
std::tuple< Types... >	tim::stl::operator/ (std::tuple< Types... > lhs, const std::tuple< Types... > &rhs)
template<typename Lhs , typename Rhs >
std::pair< Lhs, Rhs >	tim::stl::operator/ (std::pair< Lhs, Rhs > lhs, const std::pair< Lhs, Rhs > &rhs)
template<typename Tp , typename... Extra>
std::vector< Tp, Extra... >	tim::stl::operator/ (std::vector< Tp, Extra... > lhs, const std::vector< Tp, Extra... > &rhs)
std::tuple	tim::math::abs (std::tuple<>)
std::tuple	tim::math::sqrt (std::tuple<>)
std::tuple	tim::math::pow (std::tuple<>, double)
std::tuple	tim::math::sqr (std::tuple<>)
std::tuple	tim::math::min (const std::tuple<> &, const std::tuple<> &)
std::tuple	tim::math::max (const std::tuple<> &, const std::tuple<> &)
void	tim::math::assign (std::tuple<> &, std::tuple<> &&)
std::tuple &	tim::math::plus (std::tuple<> &lhs, const std::tuple<> &)
std::tuple &	tim::math::minus (std::tuple<> &lhs, const std::tuple<> &)
std::tuple &	tim::math::multiply (std::tuple<> &lhs, const std::tuple<> &)
std::tuple &	tim::math::divide (std::tuple<> &lhs, const std::tuple<> &)
std::tuple	tim::math::percent_diff (const std::tuple<> &, const std::tuple<> &)
template<typename Up >
std::tuple &	tim::math::plus (std::tuple<> &lhs, Up &&)
template<typename Up >
std::tuple &	tim::math::minus (std::tuple<> &lhs, Up &&)
template<typename Up >
std::tuple &	tim::math::multiply (std::tuple<> &lhs, Up &&)
template<typename Up >
std::tuple &	tim::math::divide (std::tuple<> &lhs, Up &&)
std::tuple &	tim::math::divide (std::tuple<> &lhs, uint64_t)
std::tuple &	tim::math::divide (std::tuple<> &lhs, int64_t)
null_type	tim::math::abs (null_type)
null_type	tim::math::sqrt (null_type)
null_type	tim::math::pow (null_type, double)
null_type	tim::math::sqr (null_type)
null_type	tim::math::min (const null_type &, const null_type &)
null_type	tim::math::max (const null_type &, const null_type &)
void	tim::math::assign (null_type &, null_type &&)
null_type &	tim::math::plus (null_type &lhs, const null_type &)
null_type &	tim::math::minus (null_type &lhs, const null_type &)
null_type &	tim::math::multiply (null_type &lhs, const null_type &)
null_type &	tim::math::divide (null_type &lhs, const null_type &)
null_type	tim::math::percent_diff (const null_type &, const null_type &)
template<typename Up >
null_type &	tim::math::plus (null_type &lhs, Up &&)
template<typename Up >
null_type &	tim::math::minus (null_type &lhs, Up &&)
template<typename Up >
null_type &	tim::math::multiply (null_type &lhs, Up &&)
template<typename Up >
null_type &	tim::math::divide (null_type &lhs, Up &&)
null_type &	tim::math::divide (null_type &lhs, uint64_t)
null_type &	tim::math::divide (null_type &lhs, int64_t)
type_list	tim::math::pow (type_list<>, double)
type_list	tim::math::min (const type_list<> &, const type_list<> &)
type_list	tim::math::max (const type_list<> &, const type_list<> &)
void	tim::math::assign (type_list<> &, type_list<> &&)
type_list &	tim::math::plus (type_list<> &lhs, const type_list<> &)
type_list &	tim::math::minus (type_list<> &lhs, const type_list<> &)
type_list &	tim::math::multiply (type_list<> &lhs, const type_list<> &)
type_list &	tim::math::divide (type_list<> &lhs, const type_list<> &)
type_list	tim::math::percent_diff (const type_list<> &, const type_list<> &)
template<typename Up >
type_list &	tim::math::plus (type_list<> &lhs, Up &&)
template<typename Up >
type_list &	tim::math::minus (type_list<> &lhs, Up &&)
template<typename Up >
type_list &	tim::math::multiply (type_list<> &lhs, Up &&)
template<typename Up >
type_list &	tim::math::divide (type_list<> &lhs, Up &&)
type_list &	tim::math::divide (type_list<> &lhs, uint64_t)
type_list &	tim::math::divide (type_list<> &lhs, int64_t)

Variables
type_list	tim::math::abs (type_list<>)
type_list	tim::math::sqrt (type_list<>)
type_list	tim::math::sqr (type_list<>)

Macro Definition Documentation

TIMEMORY_MATH_NULL_TYPE_OVERLOAD

#define TIMEMORY_MATH_NULL_TYPE_OVERLOAD

(

TYPE

)

Definition at line 361 of file fwd.hpp.