# Numeric Operators Library Reference

`default_`
T
T const
T const &
`one`
T
T const
T const &
mpl::if_::type< is_empty< T >, default_< T >, one< T > >
`zero`
T
T const
T const &
mpl::if_::type< is_empty< T >, default_< T >, zero< T > >
boost::numeric::functional::as_max_base< Arg, void >
Arg
remove_const< Arg >::type
std::numeric_limits< typename remove_const< Arg >::type >::is_specialized
remove_const< Arg >::type `Arg &`
boost::numeric::functional::as_min_base< Arg, void >
Arg
remove_const< Arg >::type
std::numeric_limits< typename remove_const< Arg >::type >::is_specialized
remove_const< Arg >::type `Arg &`
Arg
typename enable_if< is_floating_point< Arg > >::type
Arg
remove_const< Arg >::type
std::numeric_limits< typename remove_const< Arg >::type >::is_specialized
remove_const< Arg >::type `Arg &`
boost::numeric::functional::as_one_base< Arg, void >
Arg
remove_const< Arg >::type
remove_const< Arg >::type `Arg &`
boost::numeric::functional::as_zero_base< Arg, void >
Arg
remove_const< Arg >::type
remove_const< Arg >::type `Arg &`
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::assign_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >()=lvalue< Right >())>
result_type `Left &` `Right &`

left = right

typename tag<Arg>::type
boost::numeric::functional::complement_base< Arg, void >
void
std::unary_function< Arg, typeof(~ lvalue< Arg >())>
result_type `Arg &`

~ arg

typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::divides_base< Left, Right, void >
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::divides_assign_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >()/=lvalue< Right >())>
result_type `Left &` `Right &`

left /= right

void
std::binary_function< Left, Right, typeof(lvalue< Left >()/lvalue< Right >())>
result_type `Left &` `Right &`

left / right

typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::equal_to_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >()==lvalue< Right >())>
result_type `Left &` `Right &`

left == right

boost::numeric::functional::fdiv_base< Left, Right, void >
boost::numeric::functional::divides< Left, Right >
Left
Right
typename enable_if< are_integral< Left
Right > >::type
boost::numeric::functional::divides< double const, double const >
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::greater_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >() > lvalue< Right >())>
result_type `Left &` `Right &`

left > right

typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::greater_equal_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >() >=lvalue< Right >())>
result_type `Left &` `Right &`

left >= right

Left &
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::less_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >()< lvalue< Right >())>
result_type `Left &` `Right &`

left < right

typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::less_equal_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >()<=lvalue< Right >())>
result_type `Left &` `Right &`

left <= right

typename tag<Arg>::type
boost::numeric::functional::logical_not_base< Arg, void >
void
std::unary_function< Arg, typeof(! lvalue< Arg >())>
result_type `Arg &`

! arg

boost::numeric::functional::max_assign_base< Left, Right, void >
Left
Right
void
void `Left &` `Right &`
boost::numeric::functional::min_assign_base< Left, Right, void >
Left
Right
void
void `Left &` `Right &`
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::minus_base< Left, Right, void >
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::minus_assign_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >() -=lvalue< Right >())>
result_type `Left &` `Right &`

left -= right

void
std::binary_function< Left, Right, typeof(lvalue< Left >() - lvalue< Right >())>
result_type `Left &` `Right &`

left - right

typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::modulus_base< Left, Right, void >
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::modulus_assign_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >() %=lvalue< Right >())>
result_type `Left &` `Right &`

left %= right

void
std::binary_function< Left, Right, typeof(lvalue< Left >() % lvalue< Right >())>
result_type `Left &` `Right &`

left % right

typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::multiplies_base< Left, Right, void >
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::multiplies_assign_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >() *=lvalue< Right >())>
result_type `Left &` `Right &`

left *= right

void
std::binary_function< Left, Right, typeof(lvalue< Left >() *lvalue< Right >())>
result_type `Left &` `Right &`

left * right

typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::not_equal_to_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >() !=lvalue< Right >())>
result_type `Left &` `Right &`

left != right

typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::plus_base< Left, Right, void >
typename tag<Left>::type
typename tag<Right>::type
boost::numeric::functional::plus_assign_base< Left, Right, void >
void
std::binary_function< Left, Right, typeof(lvalue< Left >()+=lvalue< Right >())>
result_type `Left &` `Right &`

left += right

void
std::binary_function< Left, Right, typeof(lvalue< Left >()+lvalue< Right >())>
result_type `Left &` `Right &`

left + right

boost::numeric::functional::promote_base< To, From, void >
From
To
To `From &`
ToFrom
ToFrom
void
ToFrom
ToFrom
ToFrom & `ToFrom &`
typename tag<Arg>::type
boost::numeric::functional::unary_minus_base< Arg, void >
void
std::unary_function< Arg, typeof(- lvalue< Arg >())>
result_type `Arg &`

- arg

typename tag<Arg>::type
boost::numeric::functional::unary_plus_base< Arg, void >
void
std::unary_function< Arg, typeof(+lvalue< Arg >())>
result_type `Arg &`

+ arg

lazy_disable_if< is_const< From >, mpl::if_< is_same< To, From >, To &, To > >::type `From &`
mpl::if_< is_same< To const, From const >, To const &, To const >::type `From const &`
disable_if< mpl::or_< is_same< T, U >, is_same< std::complex< T >, U > >, std::complex< T > >::type `std::complex< T >` `U const &`
disable_if< mpl::or_< is_same< T, U >, is_same< std::complex< T >, U > >, std::complex< T > >::type `std::complex< T >` `U const &`
T
std_valarray_tag
T
remove_const< T >::type
remove_const< T >::type `T &`
T
std_valarray_tag
T
remove_const< T >::type
remove_const< T >::type `T &`
T
std_valarray_tag
T
remove_const< T >::type
remove_const< T >::type `T &`
T
std_valarray_tag
T
remove_const< T >::type
remove_const< T >::type `T &`
Left
Right
std_valarray_tag
RightTag
mpl::if_::type< are_integral< Left::value_type, Right >, divides< Left, double const >, divides< Left, Right > >
Left
Right
std_valarray_tag
std_valarray_tag
Left
Right
void
void `Left &` `Right &`
Left
Right
std_valarray_tag
std_valarray_tag
Left
Right
void
void `Left &` `Right &`
bool const
From
void
std_valarray_tag
boost::numeric::functional::promote< bool, From, void, std_valarray_tag >
bool
From
void
std_valarray_tag
From
bool
bool `From &`
To
From
std_valarray_tag
std_valarray_tag
From
To
To `From &`
ToFrom
ToFrom
std_valarray_tag
std_valarray_tag
ToFrom
ToFrom
ToFrom & `ToFrom &`
std::valarray< T >
std_valarray_tag
unspecified `std::valarray< Left > const &` `Right const &`
unspecified `std::valarray< Left > const &` `Right const &`
unspecified `std::valarray< Left > const &` `std::valarray< Right > const &`
T
std_vector_tag
T
remove_const< T >::type
remove_const< T >::type `T &`
T
std_vector_tag
T
remove_const< T >::type
remove_const< T >::type `T &`
T
std_vector_tag
T
remove_const< T >::type
remove_const< T >::type `T &`
T
std_vector_tag
T
remove_const< T >::type
remove_const< T >::type `T &`
Left
Right
std_vector_tag
void
mpl::if_::type< are_integral< Left::value_type, Right >, divides< Left, double const >, divides< Left, Right > >
Left
Right
std_vector_tag
std_vector_tag
Left
Right
void
void `Left &` `Right &`
Left
Right
std_vector_tag
std_vector_tag
Left
Right
void
void `Left &` `Right &`
To
From
std_vector_tag
std_vector_tag
From
To
To `From &`
ToFrom
ToFrom
std_vector_tag
std_vector_tag
ToFrom
ToFrom
ToFrom & `ToFrom &`
std::vector< T
Al >
std_vector_tag
unspecified `std::vector< Left > const &` `Right const &`
std::vector< typename `functional::divides`< Left, Right >::result_type > `std::vector< Left > const &` `std::vector< Right > const &`
unspecified `std::vector< Left > const &` `Right const &`
unspecified `Left const &` `std::vector< Right > const &`
std::vector< typename `functional::multiplies`< Left, Right >::result_type > `std::vector< Left > const &` `std::vector< Right > const &`
std::vector< typename `functional::plus`< Left, Right >::result_type > `std::vector< Left > const &` `std::vector< Right > const &`
std::vector< typename `functional::minus`< Left, Right >::result_type > `std::vector< Left > const &` `std::vector< Right > const &`
std::vector< Left > & `std::vector< Left > &` `std::vector< Left > const &`
std::vector< typename `functional::unary_minus`< Arg >::result_type > `std::vector< Arg > const &`