/////////////////////////////////////////////////////////////////////////////// | |
/// \file functional.hpp | |
/// | |
// Copyright 2005 Eric Niebler. Distributed under the Boost | |
// Software License, Version 1.0. (See accompanying file | |
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
#ifndef BOOST_NUMERIC_FUNCTIONAL_HPP_EAN_08_12_2005 | |
#define BOOST_NUMERIC_FUNCTIONAL_HPP_EAN_08_12_2005 | |
#include <limits> | |
#include <functional> | |
#include <boost/mpl/if.hpp> | |
#include <boost/mpl/and.hpp> | |
#include <boost/type_traits/remove_const.hpp> | |
#include <boost/type_traits/add_reference.hpp> | |
#include <boost/type_traits/is_empty.hpp> | |
#include <boost/type_traits/is_integral.hpp> | |
#include <boost/type_traits/is_floating_point.hpp> | |
#include <boost/utility/enable_if.hpp> | |
#include <boost/typeof/typeof.hpp> | |
#include <boost/accumulators/numeric/functional_fwd.hpp> | |
#include <boost/accumulators/numeric/detail/function1.hpp> | |
#include <boost/accumulators/numeric/detail/function2.hpp> | |
#include <boost/accumulators/numeric/detail/pod_singleton.hpp> | |
#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT | |
# include <boost/accumulators/numeric/functional/vector.hpp> | |
#endif | |
#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT | |
# include <boost/accumulators/numeric/functional/valarray.hpp> | |
#endif | |
#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT | |
# include <boost/accumulators/numeric/functional/complex.hpp> | |
#endif | |
/// INTERNAL ONLY | |
/// | |
#define BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED | |
#ifdef BOOST_NUMERIC_FUNCTIONAL_DOXYGEN_INVOKED | |
// Hack to make Doxygen show the inheritance relationships | |
/// INTERNAL ONLY | |
/// | |
namespace std | |
{ | |
/// INTERNAL ONLY | |
/// | |
template<class Arg, class Ret> struct unary_function {}; | |
/// INTERNAL ONLY | |
/// | |
template<class Left, class Right, class Ret> struct binary_function {}; | |
} | |
#endif | |
namespace boost { namespace numeric | |
{ | |
namespace functional | |
{ | |
/// INTERNAL ONLY | |
/// | |
template<typename A0, typename A1> | |
struct are_integral | |
: mpl::and_<is_integral<A0>, is_integral<A1> > | |
{}; | |
template<typename Left, typename Right> | |
struct left_ref | |
{ | |
typedef Left &type; | |
}; | |
namespace detail | |
{ | |
template<typename T> | |
T &lvalue_of(); | |
} | |
} | |
// TODO: handle complex weight, valarray, MTL vectors | |
/// INTERNAL ONLY | |
/// | |
#define BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(Name, Op) \ | |
namespace functional \ | |
{ \ | |
template<typename Arg> \ | |
struct result_of_ ## Name \ | |
{ \ | |
BOOST_TYPEOF_NESTED_TYPEDEF_TPL( \ | |
nested \ | |
, Op boost::numeric::functional::detail::lvalue_of<Arg>() \ | |
) \ | |
typedef typename nested::type type; \ | |
}; \ | |
template<typename Arg, typename EnableIf> \ | |
struct Name ## _base \ | |
: std::unary_function< \ | |
typename remove_const<Arg>::type \ | |
, typename result_of_ ## Name<Arg>::type \ | |
> \ | |
{ \ | |
typename result_of_ ## Name<Arg>::type operator ()(Arg &arg) const \ | |
{ \ | |
return Op arg; \ | |
} \ | |
}; \ | |
template<typename Arg, typename ArgTag> \ | |
struct Name \ | |
: Name ## _base<Arg, void> \ | |
{}; \ | |
} \ | |
namespace op \ | |
{ \ | |
struct Name \ | |
: boost::detail::function1<functional::Name<_, functional::tag<_> > > \ | |
{}; \ | |
} \ | |
namespace \ | |
{ \ | |
op::Name const &Name = boost::detail::pod_singleton<op::Name>::instance; \ | |
} \ | |
/**/ | |
/// INTERNAL ONLY | |
/// | |
#define BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(Name, Op, RetType) \ | |
namespace functional \ | |
{ \ | |
template<typename Left, typename Right, typename EnableIf> \ | |
struct result_of_ ## Name \ | |
{ \ | |
RetType(Left, Op, Right) \ | |
}; \ | |
template<typename Left, typename Right, typename EnableIf> \ | |
struct Name ## _base \ | |
: std::binary_function< \ | |
typename remove_const<Left>::type \ | |
, typename remove_const<Right>::type \ | |
, typename result_of_ ## Name<Left, Right>::type \ | |
> \ | |
{ \ | |
typename result_of_ ## Name<Left, Right>::type \ | |
operator ()(Left &left, Right &right) const \ | |
{ \ | |
return left Op right; \ | |
} \ | |
}; \ | |
template<typename Left, typename Right, typename LeftTag, typename RightTag> \ | |
struct Name \ | |
: Name ## _base<Left, Right, void> \ | |
{}; \ | |
} \ | |
namespace op \ | |
{ \ | |
struct Name \ | |
: boost::detail::function2< \ | |
functional::Name<_1, _2, functional::tag<_1>, functional::tag<_2> > \ | |
> \ | |
{}; \ | |
} \ | |
namespace \ | |
{ \ | |
op::Name const &Name = boost::detail::pod_singleton<op::Name>::instance; \ | |
} \ | |
/**/ | |
/// INTERNAL ONLY | |
/// | |
#define BOOST_NUMERIC_FUNCTIONAL_DEDUCED(Left, Op, Right) \ | |
BOOST_TYPEOF_NESTED_TYPEDEF_TPL( \ | |
nested \ | |
, boost::numeric::functional::detail::lvalue_of<Left>() Op \ | |
boost::numeric::functional::detail::lvalue_of<Right>() \ | |
) \ | |
typedef typename nested::type type; \ | |
/**/ | |
/// INTERNAL ONLY | |
/// | |
#define BOOST_NUMERIC_FUNCTIONAL_LEFT(Left, Op, Right) \ | |
typedef Left &type; \ | |
/**/ | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus, +, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(minus, -, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies, *, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(divides, /, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus, %, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater, >, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater_equal, >=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(less, <, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(less_equal, <=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(equal_to, ==, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(not_equal_to, !=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(assign, =, BOOST_NUMERIC_FUNCTIONAL_LEFT) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus_assign, +=, BOOST_NUMERIC_FUNCTIONAL_LEFT) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(minus_assign, -=, BOOST_NUMERIC_FUNCTIONAL_LEFT) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies_assign, *=, BOOST_NUMERIC_FUNCTIONAL_LEFT) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(divides_assign, /=, BOOST_NUMERIC_FUNCTIONAL_LEFT) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus_assign, %=, BOOST_NUMERIC_FUNCTIONAL_LEFT) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(unary_plus, +) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(unary_minus, -) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(complement, ~) | |
BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(logical_not, !) | |
#undef BOOST_NUMERIC_FUNCTIONAL_LEFT | |
#undef BOOST_NUMERIC_FUNCTIONAL_DEDUCED | |
#undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP | |
#undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP | |
namespace functional | |
{ | |
template<typename Left, typename Right, typename EnableIf> | |
struct min_assign_base | |
: std::binary_function<Left, Right, void> | |
{ | |
void operator ()(Left &left, Right &right) const | |
{ | |
if(numeric::less(right, left)) | |
{ | |
left = right; | |
} | |
} | |
}; | |
template<typename Left, typename Right, typename EnableIf> | |
struct max_assign_base | |
: std::binary_function<Left, Right, void> | |
{ | |
void operator ()(Left &left, Right &right) const | |
{ | |
if(numeric::greater(right, left)) | |
{ | |
left = right; | |
} | |
} | |
}; | |
template<typename Left, typename Right, typename EnableIf> | |
struct average_base | |
: functional::divides<Left, Right> | |
{}; | |
// partial specialization that promotes the arguments to double for | |
// integral division. | |
template<typename Left, typename Right> | |
struct average_base<Left, Right, typename enable_if<are_integral<Left, Right> >::type> | |
: functional::divides<double const, double const> | |
{}; | |
template<typename To, typename From, typename EnableIf> | |
struct promote_base | |
: std::unary_function<From, To> | |
{ | |
To operator ()(From &from) const | |
{ | |
return from; | |
} | |
}; | |
template<typename ToFrom> | |
struct promote_base<ToFrom, ToFrom, void> | |
: std::unary_function<ToFrom, ToFrom> | |
{ | |
ToFrom &operator ()(ToFrom &tofrom) | |
{ | |
return tofrom; | |
} | |
}; | |
template<typename Arg, typename EnableIf> | |
struct as_min_base | |
: std::unary_function<Arg, typename remove_const<Arg>::type> | |
{ | |
typename remove_const<Arg>::type operator ()(Arg &) const | |
{ | |
return (std::numeric_limits<typename remove_const<Arg>::type>::min)(); | |
} | |
}; | |
template<typename Arg> | |
struct as_min_base<Arg, typename enable_if<is_floating_point<Arg> >::type> | |
: std::unary_function<Arg, typename remove_const<Arg>::type> | |
{ | |
typename remove_const<Arg>::type operator ()(Arg &) const | |
{ | |
return -(std::numeric_limits<typename remove_const<Arg>::type>::max)(); | |
} | |
}; | |
template<typename Arg, typename EnableIf> | |
struct as_max_base | |
: std::unary_function<Arg, typename remove_const<Arg>::type> | |
{ | |
typename remove_const<Arg>::type operator ()(Arg &) const | |
{ | |
return (std::numeric_limits<typename remove_const<Arg>::type>::max)(); | |
} | |
}; | |
template<typename Arg, typename EnableIf> | |
struct as_zero_base | |
: std::unary_function<Arg, typename remove_const<Arg>::type> | |
{ | |
typename remove_const<Arg>::type operator ()(Arg &) const | |
{ | |
return numeric::zero<typename remove_const<Arg>::type>::value; | |
} | |
}; | |
template<typename Arg, typename EnableIf> | |
struct as_one_base | |
: std::unary_function<Arg, typename remove_const<Arg>::type> | |
{ | |
typename remove_const<Arg>::type operator ()(Arg &) const | |
{ | |
return numeric::one<typename remove_const<Arg>::type>::value; | |
} | |
}; | |
template<typename To, typename From, typename ToTag, typename FromTag> | |
struct promote | |
: promote_base<To, From, void> | |
{}; | |
template<typename Left, typename Right, typename LeftTag, typename RightTag> | |
struct min_assign | |
: min_assign_base<Left, Right, void> | |
{}; | |
template<typename Left, typename Right, typename LeftTag, typename RightTag> | |
struct max_assign | |
: max_assign_base<Left, Right, void> | |
{}; | |
template<typename Left, typename Right, typename LeftTag, typename RightTag> | |
struct average | |
: average_base<Left, Right, void> | |
{}; | |
template<typename Arg, typename Tag> | |
struct as_min | |
: as_min_base<Arg, void> | |
{}; | |
template<typename Arg, typename Tag> | |
struct as_max | |
: as_max_base<Arg, void> | |
{}; | |
template<typename Arg, typename Tag> | |
struct as_zero | |
: as_zero_base<Arg, void> | |
{}; | |
template<typename Arg, typename Tag> | |
struct as_one | |
: as_one_base<Arg, void> | |
{}; | |
} | |
namespace op | |
{ | |
template<typename To> | |
struct promote | |
: boost::detail::function1<functional::promote<To, _, typename functional::tag<To>::type, functional::tag<_> > > | |
{}; | |
struct min_assign | |
: boost::detail::function2<functional::min_assign<_1, _2, functional::tag<_1>, functional::tag<_2> > > | |
{}; | |
struct max_assign | |
: boost::detail::function2<functional::max_assign<_1, _2, functional::tag<_1>, functional::tag<_2> > > | |
{}; | |
struct average | |
: boost::detail::function2<functional::average<_1, _2, functional::tag<_1>, functional::tag<_2> > > | |
{}; | |
struct as_min | |
: boost::detail::function1<functional::as_min<_, functional::tag<_> > > | |
{}; | |
struct as_max | |
: boost::detail::function1<functional::as_max<_, functional::tag<_> > > | |
{}; | |
struct as_zero | |
: boost::detail::function1<functional::as_zero<_, functional::tag<_> > > | |
{}; | |
struct as_one | |
: boost::detail::function1<functional::as_one<_, functional::tag<_> > > | |
{}; | |
} | |
namespace | |
{ | |
op::min_assign const &min_assign = boost::detail::pod_singleton<op::min_assign>::instance; | |
op::max_assign const &max_assign = boost::detail::pod_singleton<op::max_assign>::instance; | |
op::average const &average = boost::detail::pod_singleton<op::average>::instance; | |
op::as_min const &as_min = boost::detail::pod_singleton<op::as_min>::instance; | |
op::as_max const &as_max = boost::detail::pod_singleton<op::as_max>::instance; | |
op::as_zero const &as_zero = boost::detail::pod_singleton<op::as_zero>::instance; | |
op::as_one const &as_one = boost::detail::pod_singleton<op::as_one>::instance; | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
// promote | |
template<typename To, typename From> | |
typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type | |
promote(From &from) | |
{ | |
return functional::promote<To, From>()(from); | |
} | |
template<typename To, typename From> | |
typename mpl::if_<is_same<To const, From const>, To const &, To const>::type | |
promote(From const &from) | |
{ | |
return functional::promote<To const, From const>()(from); | |
} | |
template<typename T> | |
struct default_ | |
{ | |
typedef default_ type; | |
typedef T value_type; | |
static T const value; | |
operator T const & () const | |
{ | |
return default_::value; | |
} | |
}; | |
template<typename T> | |
T const default_<T>::value = T(); | |
template<typename T> | |
struct one | |
{ | |
typedef one type; | |
typedef T value_type; | |
static T const value; | |
operator T const & () const | |
{ | |
return one::value; | |
} | |
}; | |
template<typename T> | |
T const one<T>::value = T(1); | |
template<typename T> | |
struct zero | |
{ | |
typedef zero type; | |
typedef T value_type; | |
static T const value; | |
operator T const & () const | |
{ | |
return zero::value; | |
} | |
}; | |
template<typename T> | |
T const zero<T>::value = T(); | |
template<typename T> | |
struct one_or_default | |
: mpl::if_<is_empty<T>, default_<T>, one<T> >::type | |
{}; | |
template<typename T> | |
struct zero_or_default | |
: mpl::if_<is_empty<T>, default_<T>, zero<T> >::type | |
{}; | |
}} // namespace boost::numeric | |
#endif |