namespace boost {
namespace numeric {
template<typename T> struct default_;
template<typename T> struct one;
template<typename T> struct zero;
template<typename T> struct one_or_default;
template<typename T> struct zero_or_default;
template<typename To, typename From>
lazy_disable_if< is_const< From >, mpl::if_< is_same< To, From >, To &, To > >::type
promote(From & from);
template<typename To, typename From>
mpl::if_< is_same< To const, From const >, To const &, To const >::type
promote(From const & from);
namespace functional {
template<typename Left, typename Right> struct left_ref;
template<typename Left, typename Right, typename EnableIf = void>
struct plus_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct plus;
template<typename Left, typename Right, typename EnableIf = void>
struct minus_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct minus;
template<typename Left, typename Right, typename EnableIf = void>
struct multiplies_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct multiplies;
template<typename Left, typename Right, typename EnableIf = void>
struct divides_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct divides;
template<typename Left, typename Right, typename EnableIf = void>
struct modulus_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct modulus;
template<typename Left, typename Right, typename EnableIf = void>
struct greater_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct greater;
template<typename Left, typename Right, typename EnableIf = void>
struct greater_equal_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct greater_equal;
template<typename Left, typename Right, typename EnableIf = void>
struct less_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct less;
template<typename Left, typename Right, typename EnableIf = void>
struct less_equal_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct less_equal;
template<typename Left, typename Right, typename EnableIf = void>
struct equal_to_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct equal_to;
template<typename Left, typename Right, typename EnableIf = void>
struct not_equal_to_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct not_equal_to;
template<typename Left, typename Right, typename EnableIf = void>
struct assign_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct assign;
template<typename Left, typename Right, typename EnableIf = void>
struct plus_assign_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct plus_assign;
template<typename Left, typename Right, typename EnableIf = void>
struct minus_assign_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct minus_assign;
template<typename Left, typename Right, typename EnableIf = void>
struct multiplies_assign_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct multiplies_assign;
template<typename Left, typename Right, typename EnableIf = void>
struct divides_assign_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct divides_assign;
template<typename Left, typename Right, typename EnableIf = void>
struct modulus_assign_base;
template<typename Left, typename Right,
typename LeftTag = typename tag<Left>::type,
typename RightTag = typename tag<Right>::type>
struct modulus_assign;
template<typename Arg, typename EnableIf = void> struct unary_plus_base;
template<typename Arg, typename Tag = typename tag<Arg>::type>
struct unary_plus;
template<typename Arg, typename EnableIf = void> struct unary_minus_base;
template<typename Arg, typename Tag = typename tag<Arg>::type>
struct unary_minus;
template<typename Arg, typename EnableIf = void> struct complement_base;
template<typename Arg, typename Tag = typename tag<Arg>::type>
struct complement;
template<typename Arg, typename EnableIf = void> struct logical_not_base;
template<typename Arg, typename Tag = typename tag<Arg>::type>
struct logical_not;
template<typename Left, typename Right, typename EnableIf>
struct min_assign_base;
template<typename Left, typename Right, typename EnableIf>
struct max_assign_base;
template<typename Left, typename Right, typename EnableIf> struct fdiv_base;
template<typename Left, typename Right>
struct fdiv_base<Left, Right, typename enable_if< are_integral< Left, Right > >::type>;
template<typename To, typename From, typename EnableIf> struct promote_base;
template<typename ToFrom> struct promote_base<ToFrom, ToFrom, void>;
template<typename Arg, typename EnableIf> struct as_min_base;
template<typename Arg>
struct as_min_base<Arg, typename enable_if< is_floating_point< Arg > >::type>;
template<typename Arg, typename EnableIf> struct as_max_base;
template<typename Arg, typename EnableIf> struct as_zero_base;
template<typename Arg, typename EnableIf> struct as_one_base;
template<typename To, typename From, typename ToTag, typename FromTag>
struct promote;
template<typename Left, typename Right, typename LeftTag,
typename RightTag>
struct min_assign;
template<typename Left, typename Right, typename LeftTag,
typename RightTag>
struct max_assign;
template<typename Left, typename Right, typename LeftTag,
typename RightTag>
struct fdiv;
template<typename Arg, typename Tag> struct as_min;
template<typename Arg, typename Tag> struct as_max;
template<typename Arg, typename Tag> struct as_zero;
template<typename Arg, typename Tag> struct as_one;
}
namespace op {
struct plus;
struct minus;
struct multiplies;
struct divides;
struct modulus;
struct greater;
struct greater_equal;
struct less;
struct less_equal;
struct equal_to;
struct not_equal_to;
struct assign;
struct plus_assign;
struct minus_assign;
struct multiplies_assign;
struct divides_assign;
struct modulus_assign;
struct unary_plus;
struct unary_minus;
struct complement;
struct logical_not;
template<typename To> struct promote;
struct min_assign;
struct max_assign;
struct fdiv;
struct as_min;
struct as_max;
struct as_zero;
struct as_one;
}
}
}
namespace boost {
namespace numeric {
namespace functional {
template<typename T> struct tag<std::valarray< T >>;
template<typename Left, typename Right>
struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>;
template<typename Left, typename Right>
struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>;
template<typename Left, typename Right, typename RightTag>
struct fdiv<Left, Right, std_valarray_tag, RightTag>;
template<typename To, typename From>
struct promote<To, From, std_valarray_tag, std_valarray_tag>;
template<typename ToFrom>
struct promote<ToFrom, ToFrom, std_valarray_tag, std_valarray_tag>;
template<typename From> struct promote<bool, From, void, std_valarray_tag>;
template<typename From>
struct promote<bool const, From, void, std_valarray_tag>;
template<typename T> struct as_min<T, std_valarray_tag>;
template<typename T> struct as_max<T, std_valarray_tag>;
template<typename T> struct as_zero<T, std_valarray_tag>;
template<typename T> struct as_one<T, std_valarray_tag>;
}
namespace operators {
template<typename Left, typename Right>
unspecified operator/(std::valarray< Left > const & left,
Right const & right);
template<typename Left, typename Right>
unspecified operator*(std::valarray< Left > const & left,
Right const & right);
template<typename Left, typename Right>
unspecified operator+(std::valarray< Left > const & left,
std::valarray< Right > const & right);
}
}
}
namespace boost {
namespace numeric {
namespace functional {
template<typename T, typename Al> struct tag<std::vector< T, Al >>;
template<typename Left, typename Right>
struct min_assign<Left, Right, std_vector_tag, std_vector_tag>;
template<typename Left, typename Right>
struct max_assign<Left, Right, std_vector_tag, std_vector_tag>;
template<typename Left, typename Right>
struct fdiv<Left, Right, std_vector_tag, void>;
template<typename To, typename From>
struct promote<To, From, std_vector_tag, std_vector_tag>;
template<typename ToFrom>
struct promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag>;
template<typename T> struct as_min<T, std_vector_tag>;
template<typename T> struct as_max<T, std_vector_tag>;
template<typename T> struct as_zero<T, std_vector_tag>;
template<typename T> struct as_one<T, std_vector_tag>;
}
namespace operators {
template<typename Left, typename Right>
unspecified operator/(std::vector< Left > const & left,
Right const & right);
template<typename Left, typename Right>
std::vector< typename functional::divides< Left, Right >::result_type >
operator/(std::vector< Left > const & left,
std::vector< Right > const & right);
template<typename Left, typename Right>
unspecified operator*(std::vector< Left > const & left,
Right const & right);
template<typename Left, typename Right>
unspecified operator*(Left const & left,
std::vector< Right > const & right);
template<typename Left, typename Right>
std::vector< typename functional::multiplies< Left, Right >::result_type >
operator*(std::vector< Left > const & left,
std::vector< Right > const & right);
template<typename Left, typename Right>
std::vector< typename functional::plus< Left, Right >::result_type >
operator+(std::vector< Left > const & left,
std::vector< Right > const & right);
template<typename Left, typename Right>
std::vector< typename functional::minus< Left, Right >::result_type >
operator-(std::vector< Left > const & left,
std::vector< Right > const & right);
template<typename Left>
std::vector< Left > &
operator+=(std::vector< Left > & left,
std::vector< Left > const & right);
template<typename Arg>
std::vector< typename functional::unary_minus< Arg >::result_type >
operator-(std::vector< Arg > const & arg);
}
}
}