FM / detail

/usr/include/boost/multiprecision/detail/

/usr/include/boost/multiprecision/detail

Name	Size	Mode	Actions
functions/	-	0755	rm
atomic.hpp	3430	0644	edit dl rm
big_lanczos.hpp	1112	0644	edit dl rm
bitscan.hpp	8793	0644	edit dl rm
constexpr.hpp	1113	0644	edit dl rm
default_ops.hpp	224929	0644	edit dl rm
digits.hpp	647	0644	edit dl rm
dynamic_array.hpp	1226	0644	edit dl rm
et_ops.hpp	101821	0644	edit dl rm
float_string_cvt.hpp	8551	0644	edit dl rm
generic_interconvert.hpp	21355	0644	edit dl rm
integer_ops.hpp	17319	0644	edit dl rm
itos.hpp	1101	0644	edit dl rm
min_max.hpp	5120	0644	edit dl rm
no_et_ops.hpp	34574	0644	edit dl rm
number_base.hpp	76769	0644	edit dl rm
number_compare.hpp	44646	0644	edit dl rm
precision.hpp	6886	0644	edit dl rm
rebind.hpp	851	0644	edit dl rm
ublas_interop.hpp	4292	0644	edit dl rm
utype_helper.hpp	6125	0644	edit dl rm

Edit: /usr/include/boost/multiprecision/detail/et_ops.hpp (101821B)

#ifndef BOOST_MP_ET_OPS_HPP
#define BOOST_MP_ET_OPS_HPP

namespace boost { namespace multiprecision {

//
// Non-member operators for number:
//
// Unary operators first.
// Note that these *must* return by value, even though that's somewhat against
// existing practice. The issue is that in C++11 land one could easily and legitimately
// write:
// auto x = +1234_my_user_defined_suffix;
// which would result in a dangling-reference-to-temporary if unary + returned a reference
// to it's argument. While return-by-value is obviously inefficient in other situations
// the reality is that no one ever uses unary operator+ anyway...!
//
template <class B, expression_template_option ExpressionTemplates>
inline BOOST_CONSTEXPR const number<B, ExpressionTemplates> operator+(const number<B, ExpressionTemplates>& v) { return v; }
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_CONSTEXPR const detail::expression<tag, Arg1, Arg2, Arg3, Arg4> operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return v; }
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, number<B, et_on> > operator-(const number<B, et_on>& v)
{
 BOOST_STATIC_ASSERT_MSG(is_signed_number::value, "Negating an unsigned type results in ill-defined behavior.");
 return detail::expression<detail::negate, number<B, et_on> >(v);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on> operator-(number<B, et_on>&& v)
{
 BOOST_STATIC_ASSERT_MSG(is_signed_number::value, "Negating an unsigned type results in ill-defined behavior.");
 return detail::expression<detail::negate, number<B, et_on> >(v);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v)
{
 BOOST_STATIC_ASSERT_MSG((is_signed_number<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value), "Negating an unsigned type results in ill-defined behavior.");
 return detail::expression<detail::negate, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(v);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::complement_immediates, number<B, et_on> > >::type
operator~(const number<B, et_on>& v) { return detail::expression<detail::complement_immediates, number<B, et_on> >(v); }
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator~(number<B, et_on>&& v) { return detail::expression<detail::complement_immediates, number<B, et_on> >(v); }
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
 detail::expression<detail::bitwise_complement, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator~(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& v) { return detail::expression<detail::bitwise_complement, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(v); }
//
// Then addition:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >
operator+(const number<B, et_on>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator+(number<B, et_on>&& a, const number<B, et_on>& b)
{
 return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator+(const number<B, et_on>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator+(number<B, et_on>&& a, number<B, et_on>&& b)
{
 return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::add_immediates, number<B, et_on>, V> >::type
operator+(const number<B, et_on>& a, const V& b)
{
 return detail::expression<detail::add_immediates, number<B, et_on>, V>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, number<B, et_on> >::type
operator+(number<B, et_on>&& a, const V& b)
{
 return detail::expression<detail::add_immediates, number<B, et_on>, V>(a, b);
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::add_immediates, V, number<B, et_on> > >::type
operator+(const V& a, const number<B, et_on>& b)
{
 return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, number<B, et_on> >::type
operator+(const V& a, number<B, et_on>&& b)
{
 return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b);
}
#endif
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
operator+(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type
operator+(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::plus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
 return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>, detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator+(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::plus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>, detail::expression<detail::plus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator+(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::plus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Fused multiply add:
//
template <class V, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>,
 detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
operator+(const V& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(b.left(), b.right(), a);
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>,
 detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(a.left(), a.right(), b);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
operator+(const number<B, ET>& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type
operator+(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a);
}
#endif
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type
operator+(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::multiply_add, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
}
#endif
//
// Fused multiply subtract:
//
template <class V, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>,
 detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> > >::type
operator-(const V& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(b.left(), b.right(), a));
}
template <class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::result_type>,
 detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V> >::type
operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, V>(a.left(), a.right(), b);
}
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >
operator-(const number<B, ET>& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >::result_type
operator-(number<B, ET>&& a, const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> > >(detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(b.left(), b.right(), a));
}
#endif
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >
operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >::result_type
operator-(const detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::multiply_subtract, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::left_type, typename detail::expression<detail::multiply_immediates, Arg1, Arg2, Arg3, Arg4>::right_type, number<B, ET> >(a.left(), a.right(), b);
}
#endif
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, Arg1>
operator+(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::minus, number<B, ET>, Arg1>(a, b.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type
operator+(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::minus, number<B, ET>, Arg1>(a, b.left_ref());
}
#endif
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, Arg1>
operator+(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::minus, number<B, ET>, Arg1>(b, a.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::minus, number<B, ET>, Arg1>::result_type
operator+(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::minus, number<B, ET>, Arg1>(b, a.left_ref());
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
operator+(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >::result_type
operator+(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >::result_type
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref());
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::subtract_immediates, V, number<B, et_on> > >::type
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
 return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(b, a.left_ref());
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> > >::type
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
 return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(b, a.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, typename detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
{
 return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(b, a.left_ref());
}
#endif
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> > >::type
operator+(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, typename detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
operator+(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::subtract_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >
operator+(const detail::expression<detail::negate, number<B, et_on> >& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b.left_ref()));
}
//
// Subtraction:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >
operator-(const number<B, et_on>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator-(number<B, et_on>&& a, const number<B, et_on>& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator-(const number<B, et_on>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator-(number<B, et_on>&& a, number<B, et_on>&& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::subtract_immediates, number<B, et_on>, V> >::type
operator-(const number<B, et_on>& a, const V& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, V>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, number<B, et_on> >::type
operator-(number<B, et_on>&& a, const V& b)
{
 return detail::expression<detail::subtract_immediates, number<B, et_on>, V>(a, b);
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::subtract_immediates, V, number<B, et_on> > >::type
operator-(const V& a, const number<B, et_on>& b)
{
 return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, number<B, et_on> >::type
operator-(const V& a, number<B, et_on>&& b)
{
 return detail::expression<detail::subtract_immediates, V, number<B, et_on> >(a, b);
}
#endif
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
operator-(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type
operator-(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::minus, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
 return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>, detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator-(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::minus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>, detail::expression<detail::minus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator-(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::minus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::plus, number<B, ET>, Arg1>
operator-(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::plus, number<B, ET>, Arg1>(a, b.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::plus, number<B, ET>, Arg1>::result_type
operator-(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::plus, number<B, ET>, Arg1>(a, b.left_ref());
}
#endif
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >
operator-(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >(
 detail::expression<detail::plus, number<B, ET>, Arg1>(b, a.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >::result_type
operator-(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::plus, number<B, ET>, Arg1> >(
 detail::expression<detail::plus, number<B, ET>, Arg1>(b, a.left_ref()));
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >
operator-(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >::result_type
operator-(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref());
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >::result_type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::add_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, V> > >::type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, V> >(detail::expression<detail::add_immediates, number<B, et_on>, V>(a.left_ref(), b));
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > > >::type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, typename detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
operator-(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> > >(detail::expression<detail::add_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::add_immediates, V, number<B, et_on> > >::type
operator-(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::add_immediates, V, number<B, et_on> >(a, b.left_ref());
}
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> > >::type
operator-(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, typename detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >::result_type>::type
operator-(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::add_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref());
}
#endif
//
// Multiplication:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >
operator*(const number<B, et_on>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator*(number<B, et_on>&& a, const number<B, et_on>& b)
{
 return detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator*(const number<B, et_on>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator*(number<B, et_on>&& a, number<B, et_on>&& b)
{
 return detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >::type
operator*(const number<B, et_on>& a, const V& b)
{
 return detail::expression<detail::multiply_immediates, number<B, et_on>, V>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, number<B, et_on> >::type
operator*(number<B, et_on>&& a, const V& b)
{
 return detail::expression<detail::multiply_immediates, number<B, et_on>, V>(a, b);
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::multiply_immediates, V, number<B, et_on> > >::type
operator*(const V& a, const number<B, et_on>& b)
{
 return detail::expression<detail::multiply_immediates, V, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, number<B, et_on> >::type
operator*(const V& a, number<B, et_on>&& b)
{
 return detail::expression<detail::multiply_immediates, V, number<B, et_on> >(a, b);
}
#endif
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
operator*(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type
operator*(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::multiplies, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
 return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>, detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator*(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::multiplies, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>, detail::expression<detail::multiplies, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator*(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::multiplies, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >
operator*(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
 detail::expression<detail::multiplies, number<B, ET>, Arg1>(a, b.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >::result_type
operator*(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
 detail::expression<detail::multiplies, number<B, ET>, Arg1>(a, b.left_ref()));
}
#endif
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >
operator*(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
 detail::expression<detail::multiplies, number<B, ET>, Arg1>(b, a.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >::result_type
operator*(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiplies, number<B, ET>, Arg1> >(
 detail::expression<detail::multiplies, number<B, ET>, Arg1>(b, a.left_ref()));
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >
operator*(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type
operator*(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >::result_type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B, et_on> >(b, a.left_ref()));
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> > >::type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, V>(a.left_ref(), b));
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > >::type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >::result_type >::type
operator*(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> > >::type
operator*(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, V> >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, V>(b.left_ref(), a));
}
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > > >::type
operator*(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(b.left_ref(), a));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, typename detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
operator*(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> > >(
 detail::expression<detail::multiply_immediates, number<B, et_on>, number<B2, ET> >(b.left_ref(), a));
}
#endif
//
// Division:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >
operator/(const number<B, et_on>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator/(number<B, et_on>&& a, const number<B, et_on>& b)
{
 return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator/(const number<B, et_on>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR number<B, et_on>
operator/(number<B, et_on>&& a, number<B, et_on>&& b)
{
 return detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::divide_immediates, number<B, et_on>, V> >::type
operator/(const number<B, et_on>& a, const V& b)
{
 return detail::expression<detail::divide_immediates, number<B, et_on>, V>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, number<B, et_on> >::type
operator/(number<B, et_on>&& a, const V& b)
{
 return detail::expression<detail::divide_immediates, number<B, et_on>, V>(a, b);
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::divide_immediates, V, number<B, et_on> > >::type
operator/(const V& a, const number<B, et_on>& b)
{
 return detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, number<B, et_on> >::type
operator/(const V& a, number<B, et_on>&& b)
{
 return detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b);
}
#endif
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >
operator/(const number<B, ET>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type
operator/(number<B, ET>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::divides, number<B, ET>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::result_type
operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >
operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
 return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>, detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator/(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::divides, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>, detail::expression<detail::divides, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator/(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::divides, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries:
//
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >
operator/(const number<B, ET>& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >(
 detail::expression<detail::divides, number<B, ET>, Arg1>(a, b.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, expression_template_option ET, class Arg1, class Arg2, class Arg3, class Arg4>
inline typename detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >::result_type
operator/(number<B, ET>&& a, const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divides, number<B, ET>, Arg1> >(
 detail::expression<detail::divides, number<B, ET>, Arg1>(a, b.left_ref()));
}
#endif
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >
operator/(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, const number<B, ET>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >(
 detail::expression<detail::divides, Arg1, number<B, ET> >(a.left_ref(), b));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >::result_type
operator/(const detail::expression<detail::negate, Arg1, Arg2, Arg3, Arg4>& a, number<B, ET>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divides, Arg1, number<B, ET> > >(
 detail::expression<detail::divides, Arg1, number<B, ET> >(a.left_ref(), b));
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >
operator/(const number<B, et_on>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >::result_type
operator/(number<B, et_on>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a, b.left_ref()));
}
#endif
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B, et_on>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >::result_type
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, number<B, et_on>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> > >(
 detail::expression<detail::divide_immediates, number<B, et_on>, number<B, et_on> >(a.left_ref(), b));
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, V> > >::type
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const V& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, V> >(
 detail::expression<detail::divide_immediates, number<B, et_on>, V>(a.left_ref(), b));
}
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > > >::type
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, const number<B2, ET>& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >(
 detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class B2, expression_template_option ET>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >::result_type>::type
operator/(const detail::expression<detail::negate, number<B, et_on> >& a, number<B2, ET>&& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> > >(
 detail::expression<detail::divide_immediates, number<B, et_on>, number<B2, ET> >(a.left_ref(), b));
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<V, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, et_on> > > >::type
operator/(const V& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, V, number<B, et_on> > >(
 detail::expression<detail::divide_immediates, V, number<B, et_on> >(a, b.left_ref()));
}
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, number<B, et_on> >, detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > > >::type
operator/(const number<B2, ET>& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >(
 detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref()));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B2, expression_template_option ET, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if<is_compatible_arithmetic_type<number<B2, ET>, typename detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >::result_type >, number<B, et_on> >::type
operator/(number<B2, ET>&& a, const detail::expression<detail::negate, number<B, et_on> >& b)
{
 return detail::expression<detail::negate, detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> > >(
 detail::expression<detail::divide_immediates, number<B2, ET>, number<B, et_on> >(a, b.left_ref()));
}
#endif
//
// Modulus:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> > >::type
operator%(const number<B, et_on>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator%(number<B, et_on>&& a, const number<B, et_on>& b)
{
 return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator%(const number<B, et_on>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator%(number<B, et_on>&& a, number<B, et_on>&& b)
{
 return detail::expression<detail::modulus_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 detail::expression<detail::modulus_immediates, number<B, et_on>, V> >::type
operator%(const number<B, et_on>& a, const V& b)
{
 return detail::expression<detail::modulus_immediates, number<B, et_on>, V>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator%(number<B, et_on>&& a, const V& b)
{
 return detail::expression<detail::modulus_immediates, number<B, et_on>, V>(a, b);
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 detail::expression<detail::modulus_immediates, V, number<B, et_on> > >::type
operator%(const V& a, const number<B, et_on>& b)
{
 return detail::expression<detail::modulus_immediates, V, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator%(const V& a, number<B, et_on>&& b)
{
 return detail::expression<detail::modulus_immediates, V, number<B, et_on> >(a, b);
}
#endif
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator%(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 typename detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
operator%(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::modulus, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 typename detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type >::type
operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
 detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
 return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator%(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::modulus, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::modulus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator%(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::modulus, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Left shift:
//
template <class B, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_integral::value && (number_category::value == number_kind_integer), detail::expression<detail::shift_left, number<B, et_on>, I> >::type
operator<<(const number<B, et_on>& a, const I& b)
{
 return detail::expression<detail::shift_left, number<B, et_on>, I>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_integral::value && (number_category::value == number_kind_integer), number<B, et_on> >::type
operator<<(number<B, et_on>&& a, const I& b)
{
 return detail::expression<detail::shift_left, number<B, et_on>, I>(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_integral::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
operator<<(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
{
 return detail::expression<detail::shift_left, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
}
//
// Right shift:
//
template <class B, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_integral::value && (number_category::value == number_kind_integer),
 detail::expression<detail::shift_right, number<B, et_on>, I> >::type
operator>>(const number<B, et_on>& a, const I& b)
{
 return detail::expression<detail::shift_right, number<B, et_on>, I>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_integral::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator>>(number<B, et_on>&& a, const I& b)
{
 return detail::expression<detail::shift_right, number<B, et_on>, I>(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class I>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_integral::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I> >::type
operator>>(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const I& b)
{
 return detail::expression<detail::shift_right, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, I>(a, b);
}
//
// Bitwise AND:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> > >::type
operator&(const number<B, et_on>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator&(number<B, et_on>&& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator&(const number<B, et_on>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator&(number<B, et_on>&& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V> >::type
operator&(const number<B, et_on>& a, const V& b)
{
 return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator&(number<B, et_on>&& a, const V& b)
{
 return detail::expression<detail::bitwise_and_immediates, number<B, et_on>, V>(a, b);
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> > >::type
operator&(const V& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator&(const V& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_and_immediates, V, number<B, et_on> >(a, b);
}
#endif
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator&(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 typename detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type >::type
operator&(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_and, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 typename detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
 detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
 return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator&(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::bitwise_and, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::bitwise_and, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator&(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_and, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Bitwise OR:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> > >::type
operator|(const number<B, et_on>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator|(number<B, et_on>&& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator|(const number<B, et_on>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator|(number<B, et_on>&& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V> >::type
operator|(const number<B, et_on>& a, const V& b)
{
 return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator|(number<B, et_on>&& a, const V& b)
{
 return detail::expression<detail::bitwise_or_immediates, number<B, et_on>, V>(a, b);
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> > >::type
operator|(const V& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator|(const V& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_or_immediates, V, number<B, et_on> >(a, b);
}
#endif
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator|(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 typename detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator|(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_or, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 typename detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
 detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
 return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator|(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::bitwise_or, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::bitwise_or, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator|(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_or, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
//
// Bitwise XOR:
//
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> > >::type
operator^(const number<B, et_on>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator^(number<B, et_on>&& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator^(const number<B, et_on>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
template <class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 number<B, et_on> >::type
operator^(number<B, et_on>&& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, number<B, et_on> >(a, b);
}
#endif
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V> >::type
operator^(const number<B, et_on>& a, const V& b)
{
 return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V>(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator^(number<B, et_on>&& a, const V& b)
{
 return detail::expression<detail::bitwise_xor_immediates, number<B, et_on>, V>(a, b);
}
#endif
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> > >::type
operator^(const V& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class V, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, number<B, et_on> >::value && (number_category::value == number_kind_integer),
 number<B, et_on> >::type
operator^(const V& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_xor_immediates, V, number<B, et_on> >(a, b);
}
#endif
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator^(const number<B, et_on>& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class B, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 typename detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >::result_type>::type
operator^(number<B, et_on>&& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_xor, number<B, et_on>, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> > >::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const number<B, et_on>& b)
{
 return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category::value == number_kind_integer,
 typename detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >::result_type>::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, number<B, et_on>&& b)
{
 return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, et_on> >(a, b);
}
#endif
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class tag2, class Arg1b, class Arg2b, class Arg3b, class Arg4b>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer,
 detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> > >::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b>& b)
{
 return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, detail::expression<tag2, Arg1b, Arg2b, Arg3b, Arg4b> >(a, b);
}
template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class V>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer),
 detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V> >::type
operator^(const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& a, const V& b)
{
 return detail::expression<detail::bitwise_xor, detail::expression<tag, Arg1, Arg2, Arg3, Arg4>, V>(a, b);
}
template <class V, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c<is_compatible_arithmetic_type<V, typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value && (number_category<typename detail::expression<tag, Arg1, Arg2, Arg3, Arg4>::result_type>::value == number_kind_integer), detail::expression<detail::bitwise_xor, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> > >::type
operator^(const V& a, const detail::expression<tag, Arg1, Arg2, Arg3, Arg4>& b)
{
 return detail::expression<detail::bitwise_xor, V, detail::expression<tag, Arg1, Arg2, Arg3, Arg4> >(a, b);
}

}} // namespace boost::multiprecision

#endif

/////////////////////////////////////////////////////////////////////////////// // Copyright 2011 John Maddock. 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_MP_ET_OPS_HPP #define BOOST_MP_ET_OPS_HPP namespace boost { namespace multiprecision { // // Non-member operators for number: // // Unary operators first. // Note that these *must* return by value, even though that's somewhat against // existing practice. The issue is that in C++11 land one could easily and legitimately // write: // auto x = +1234_my_user_defined_suffix; // which would result in a dangling-reference-to-temporary if unary + returned a reference // to it's argument. While return-by-value is obviously inefficient in other situations // the reality is that no one ever uses unary operator+ anyway...! // template inline BOOST_CONSTEXPR const number operator+(const number& v) { return v; } template inline BOOST_CONSTEXPR const detail::expression operator+(const detail::expression& v) { return v; } template inline BOOST_MP_CXX14_CONSTEXPR detail::expression > operator-(const number& v) { BOOST_STATIC_ASSERT_MSG(is_signed_number::value, "Negating an unsigned type results in ill-defined behavior."); return detail::expression >(v); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR number operator-(number&& v) { BOOST_STATIC_ASSERT_MSG(is_signed_number::value, "Negating an unsigned type results in ill-defined behavior."); return detail::expression >(v); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression > operator-(const detail::expression& v) { BOOST_STATIC_ASSERT_MSG((is_signed_number::result_type>::value), "Negating an unsigned type results in ill-defined behavior."); return detail::expression >(v); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression > >::type operator~(const number& v) { return detail::expression >(v); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator~(number&& v) { return detail::expression >(v); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value == number_kind_integer, detail::expression > >::type operator~(const detail::expression& v) { return detail::expression >(v); } // // Then addition: // template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator+(const number& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR number operator+(number&& a, const number& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR number operator+(const number& a, number&& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR number operator+(number&& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression, V> >::type operator+(const number& a, const V& b) { return detail::expression, V>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, number >::type operator+(number&& a, const V& b) { return detail::expression, V>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression > >::type operator+(const V& a, const number& b) { return detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, number >::type operator+(const V& a, number&& b) { return detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, detail::expression > operator+(const number& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, detail::expression >::result_type operator+(number&& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator+(const detail::expression& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number >::result_type operator+(const detail::expression& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, detail::expression > operator+(const detail::expression& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression, V> >::type operator+(const detail::expression& a, const V& b) { return detail::expression, V>(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression > >::type operator+(const V& a, const detail::expression& b) { return detail::expression >(a, b); } // // Fused multiply add: // template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression::left_type, typename detail::expression::right_type, V> >::type operator+(const V& a, const detail::expression& b) { return detail::expression::left_type, typename detail::expression::right_type, V>(b.left(), b.right(), a); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression::left_type, typename detail::expression::right_type, V> >::type operator+(const detail::expression& a, const V& b) { return detail::expression::left_type, typename detail::expression::right_type, V>(a.left(), a.right(), b); } template inline BOOST_MP_CXX14_CONSTEXPR detail::expression::left_type, typename detail::expression::right_type, number > operator+(const number& a, const detail::expression& b) { return detail::expression::left_type, typename detail::expression::right_type, number >(b.left(), b.right(), a); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression::left_type, typename detail::expression::right_type, number >::result_type operator+(number&& a, const detail::expression& b) { return detail::expression::left_type, typename detail::expression::right_type, number >(b.left(), b.right(), a); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression::left_type, typename detail::expression::right_type, number > operator+(const detail::expression& a, const number& b) { return detail::expression::left_type, typename detail::expression::right_type, number >(a.left(), a.right(), b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression::left_type, typename detail::expression::right_type, number >::result_type operator+(const detail::expression& a, number&& b) { return detail::expression::left_type, typename detail::expression::right_type, number >(a.left(), a.right(), b); } #endif // // Fused multiply subtract: // template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression::left_type, typename detail::expression::right_type, V> > >::type operator-(const V& a, const detail::expression& b) { return detail::expression::left_type, typename detail::expression::right_type, V> >(detail::expression::left_type, typename detail::expression::right_type, V>(b.left(), b.right(), a)); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression::left_type, typename detail::expression::right_type, V> >::type operator-(const detail::expression& a, const V& b) { return detail::expression::left_type, typename detail::expression::right_type, V>(a.left(), a.right(), b); } template inline BOOST_MP_CXX14_CONSTEXPR detail::expression::left_type, typename detail::expression::right_type, number > > operator-(const number& a, const detail::expression& b) { return detail::expression::left_type, typename detail::expression::right_type, number > >(detail::expression::left_type, typename detail::expression::right_type, number >(b.left(), b.right(), a)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression::left_type, typename detail::expression::right_type, number > >::result_type operator-(number&& a, const detail::expression& b) { return detail::expression::left_type, typename detail::expression::right_type, number > >(detail::expression::left_type, typename detail::expression::right_type, number >(b.left(), b.right(), a)); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression::left_type, typename detail::expression::right_type, number > operator-(const detail::expression& a, const number& b) { return detail::expression::left_type, typename detail::expression::right_type, number >(a.left(), a.right(), b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression::left_type, typename detail::expression::right_type, number >::result_type operator-(const detail::expression& a, number&& b) { return detail::expression::left_type, typename detail::expression::right_type, number >(a.left(), a.right(), b); } #endif // // Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries: // template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, Arg1> operator+(const number& a, const detail::expression& b) { return detail::expression, Arg1>(a, b.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, Arg1>::result_type operator+(number&& a, const detail::expression& b) { return detail::expression, Arg1>(a, b.left_ref()); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, Arg1> operator+(const detail::expression& a, const number& b) { return detail::expression, Arg1>(b, a.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, Arg1>::result_type operator+(const detail::expression& a, number&& b) { return detail::expression, Arg1>(b, a.left_ref()); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator+(const number& a, const detail::expression >& b) { return detail::expression, number >(a, b.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number >::result_type operator+(number&& a, const detail::expression >& b) { return detail::expression, number >(a, b.left_ref()); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator+(const detail::expression >& a, const number& b) { return detail::expression, number >(b, a.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number >::result_type operator+(const detail::expression >& a, number&& b) { return detail::expression, number >(b, a.left_ref()); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression > >::type operator+(const detail::expression >& a, const V& b) { return detail::expression >(b, a.left_ref()); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, detail::expression, number > >::type operator+(const detail::expression >& a, const number& b) { return detail::expression, number >(b, a.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, typename detail::expression, number >::result_type>::type operator+(const detail::expression >& a, number&& b) { return detail::expression, number >(b, a.left_ref()); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, detail::expression, number > >::type operator+(const number& a, const detail::expression >& b) { return detail::expression, number >(a, b.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, typename detail::expression, number >::result_type>::type operator+(number&& a, const detail::expression >& b) { return detail::expression, number >(a, b.left_ref()); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > > operator+(const detail::expression >& a, const detail::expression >& b) { return detail::expression, number > >(detail::expression, number >(a.left_ref(), b.left_ref())); } // // Subtraction: // template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator-(const number& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR number operator-(number&& a, const number& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR number operator-(const number& a, number&& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR number operator-(number&& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression, V> >::type operator-(const number& a, const V& b) { return detail::expression, V>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, number >::type operator-(number&& a, const V& b) { return detail::expression, V>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression > >::type operator-(const V& a, const number& b) { return detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, number >::type operator-(const V& a, number&& b) { return detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, detail::expression > operator-(const number& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, detail::expression >::result_type operator-(number&& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator-(const detail::expression& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number >::result_type operator-(const detail::expression& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, detail::expression > operator-(const detail::expression& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression, V> >::type operator-(const detail::expression& a, const V& b) { return detail::expression, V>(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression > >::type operator-(const V& a, const detail::expression& b) { return detail::expression >(a, b); } // // Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries: // template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, Arg1> operator-(const number& a, const detail::expression& b) { return detail::expression, Arg1>(a, b.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, Arg1>::result_type operator-(number&& a, const detail::expression& b) { return detail::expression, Arg1>(a, b.left_ref()); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, Arg1> > operator-(const detail::expression& a, const number& b) { return detail::expression, Arg1> >( detail::expression, Arg1>(b, a.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, Arg1> >::result_type operator-(const detail::expression& a, number&& b) { return detail::expression, Arg1> >( detail::expression, Arg1>(b, a.left_ref())); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator-(const number& a, const detail::expression >& b) { return detail::expression, number >(a, b.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number >::result_type operator-(number&& a, const detail::expression >& b) { return detail::expression, number >(a, b.left_ref()); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > > operator-(const detail::expression >& a, const number& b) { return detail::expression, number > >( detail::expression, number >(b, a.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number > >::result_type operator-(const detail::expression >& a, number&& b) { return detail::expression, number > >( detail::expression, number >(b, a.left_ref())); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression, V> > >::type operator-(const detail::expression >& a, const V& b) { return detail::expression, V> >(detail::expression, V>(a.left_ref(), b)); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, detail::expression, number > > >::type operator-(const detail::expression >& a, const number& b) { return detail::expression, number > >(detail::expression, number >(a.left_ref(), b)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, typename detail::expression, number > >::result_type>::type operator-(const detail::expression >& a, number&& b) { return detail::expression, number > >(detail::expression, number >(a.left_ref(), b)); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression > >::type operator-(const V& a, const detail::expression >& b) { return detail::expression >(a, b.left_ref()); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, detail::expression, number > >::type operator-(const number& a, const detail::expression >& b) { return detail::expression, number >(a, b.left_ref()); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, typename detail::expression, number >::result_type>::type operator-(number&& a, const detail::expression >& b) { return detail::expression, number >(a, b.left_ref()); } #endif // // Multiplication: // template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator*(const number& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR number operator*(number&& a, const number& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR number operator*(const number& a, number&& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR number operator*(number&& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression, V> >::type operator*(const number& a, const V& b) { return detail::expression, V>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, number >::type operator*(number&& a, const V& b) { return detail::expression, V>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression > >::type operator*(const V& a, const number& b) { return detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, number >::type operator*(const V& a, number&& b) { return detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, detail::expression > operator*(const number& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, detail::expression >::result_type operator*(number&& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator*(const detail::expression& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number >::result_type operator*(const detail::expression& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, detail::expression > operator*(const detail::expression& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression, V> >::type operator*(const detail::expression& a, const V& b) { return detail::expression, V>(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression > >::type operator*(const V& a, const detail::expression& b) { return detail::expression >(a, b); } // // Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries: // template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, Arg1> > operator*(const number& a, const detail::expression& b) { return detail::expression, Arg1> >( detail::expression, Arg1>(a, b.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, Arg1> >::result_type operator*(number&& a, const detail::expression& b) { return detail::expression, Arg1> >( detail::expression, Arg1>(a, b.left_ref())); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, Arg1> > operator*(const detail::expression& a, const number& b) { return detail::expression, Arg1> >( detail::expression, Arg1>(b, a.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, Arg1> >::result_type operator*(const detail::expression& a, number&& b) { return detail::expression, Arg1> >( detail::expression, Arg1>(b, a.left_ref())); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > > operator*(const number& a, const detail::expression >& b) { return detail::expression, number > >( detail::expression, number >(a, b.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number > >::result_type operator*(number&& a, const detail::expression >& b) { return detail::expression, number > >( detail::expression, number >(a, b.left_ref())); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > > operator*(const detail::expression >& a, const number& b) { return detail::expression, number > >( detail::expression, number >(b, a.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number > >::result_type operator*(const detail::expression >& a, number&& b) { return detail::expression, number > >( detail::expression, number >(b, a.left_ref())); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression, V> > >::type operator*(const detail::expression >& a, const V& b) { return detail::expression, V> >( detail::expression, V>(a.left_ref(), b)); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, detail::expression, number > > >::type operator*(const detail::expression >& a, const number& b) { return detail::expression, number > >( detail::expression, number >(a.left_ref(), b)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, typename detail::expression, number > >::result_type >::type operator*(const detail::expression >& a, number&& b) { return detail::expression, number > >( detail::expression, number >(a.left_ref(), b)); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression, V> > >::type operator*(const V& a, const detail::expression >& b) { return detail::expression, V> >( detail::expression, V>(b.left_ref(), a)); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, detail::expression, number > > >::type operator*(const number& a, const detail::expression >& b) { return detail::expression, number > >( detail::expression, number >(b.left_ref(), a)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, typename detail::expression, number > >::result_type>::type operator*(number&& a, const detail::expression >& b) { return detail::expression, number > >( detail::expression, number >(b.left_ref(), a)); } #endif // // Division: // template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator/(const number& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR number operator/(number&& a, const number& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR number operator/(const number& a, number&& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR number operator/(number&& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression, V> >::type operator/(const number& a, const V& b) { return detail::expression, V>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, number >::type operator/(number&& a, const V& b) { return detail::expression, V>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression > >::type operator/(const V& a, const number& b) { return detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, number >::type operator/(const V& a, number&& b) { return detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, detail::expression > operator/(const number& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, detail::expression >::result_type operator/(number&& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > operator/(const detail::expression& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number >::result_type operator/(const detail::expression& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, detail::expression > operator/(const detail::expression& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression, V> >::type operator/(const detail::expression& a, const V& b) { return detail::expression, V>(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if::result_type>, detail::expression > >::type operator/(const V& a, const detail::expression& b) { return detail::expression >(a, b); } // // Repeat operator for negated arguments: propagate the negation to the top level to avoid temporaries: // template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, Arg1> > operator/(const number& a, const detail::expression& b) { return detail::expression, Arg1> >( detail::expression, Arg1>(a, b.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline typename detail::expression, Arg1> >::result_type operator/(number&& a, const detail::expression& b) { return detail::expression, Arg1> >( detail::expression, Arg1>(a, b.left_ref())); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression > > operator/(const detail::expression& a, const number& b) { return detail::expression > >( detail::expression >(a.left_ref(), b)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression > >::result_type operator/(const detail::expression& a, number&& b) { return detail::expression > >( detail::expression >(a.left_ref(), b)); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > > operator/(const number& a, const detail::expression >& b) { return detail::expression, number > >( detail::expression, number >(a, b.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number > >::result_type operator/(number&& a, const detail::expression >& b) { return detail::expression, number > >( detail::expression, number >(a, b.left_ref())); } #endif template inline BOOST_MP_CXX14_CONSTEXPR detail::expression, number > > operator/(const detail::expression >& a, const number& b) { return detail::expression, number > >( detail::expression, number >(a.left_ref(), b)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename detail::expression, number > >::result_type operator/(const detail::expression >& a, number&& b) { return detail::expression, number > >( detail::expression, number >(a.left_ref(), b)); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression, V> > >::type operator/(const detail::expression >& a, const V& b) { return detail::expression, V> >( detail::expression, V>(a.left_ref(), b)); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, detail::expression, number > > >::type operator/(const detail::expression >& a, const number& b) { return detail::expression, number > >( detail::expression, number >(a.left_ref(), b)); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, typename detail::expression, number > >::result_type>::type operator/(const detail::expression >& a, number&& b) { return detail::expression, number > >( detail::expression, number >(a.left_ref(), b)); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if >, detail::expression > > >::type operator/(const V& a, const detail::expression >& b) { return detail::expression > >( detail::expression >(a, b.left_ref())); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, number >, detail::expression, number > > >::type operator/(const number& a, const detail::expression >& b) { return detail::expression, number > >( detail::expression, number >(a, b.left_ref())); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if, typename detail::expression, number > >::result_type >, number >::type operator/(number&& a, const detail::expression >& b) { return detail::expression, number > >( detail::expression, number >(a, b.left_ref())); } #endif // // Modulus: // template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, number > >::type operator%(const number& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator%(number&& a, const number& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator%(const number& a, number&& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator%(number&& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), detail::expression, V> >::type operator%(const number& a, const V& b) { return detail::expression, V>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), number >::type operator%(number&& a, const V& b) { return detail::expression, V>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), detail::expression > >::type operator%(const V& a, const number& b) { return detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), number >::type operator%(const V& a, number&& b) { return detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, detail::expression > >::type operator%(const number& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, typename detail::expression, detail::expression >::result_type >::type operator%(number&& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, number > >::type operator%(const detail::expression& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, typename detail::expression, number >::result_type >::type operator%(const detail::expression& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value == number_kind_integer, detail::expression, detail::expression > >::type operator%(const detail::expression& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value && (number_category::result_type>::value == number_kind_integer), detail::expression, V> >::type operator%(const detail::expression& a, const V& b) { return detail::expression, V>(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value && (number_category::result_type>::value == number_kind_integer), detail::expression > >::type operator%(const V& a, const detail::expression& b) { return detail::expression >(a, b); } // // Left shift: // template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value && (number_category::value == number_kind_integer), detail::expression, I> >::type operator<<(const number& a, const I& b) { return detail::expression, I>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value && (number_category::value == number_kind_integer), number >::type operator<<(number&& a, const I& b) { return detail::expression, I>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value && (number_category::result_type>::value == number_kind_integer), detail::expression, I> >::type operator<<(const detail::expression& a, const I& b) { return detail::expression, I>(a, b); } // // Right shift: // template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value && (number_category::value == number_kind_integer), detail::expression, I> >::type operator>>(const number& a, const I& b) { return detail::expression, I>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value && (number_category::value == number_kind_integer), number >::type operator>>(number&& a, const I& b) { return detail::expression, I>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value && (number_category::result_type>::value == number_kind_integer), detail::expression, I> >::type operator>>(const detail::expression& a, const I& b) { return detail::expression, I>(a, b); } // // Bitwise AND: // template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, number > >::type operator&(const number& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator&(number&& a, const number& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator&(const number& a, number&& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator&(number&& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), detail::expression, V> >::type operator&(const number& a, const V& b) { return detail::expression, V>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), number >::type operator&(number&& a, const V& b) { return detail::expression, V>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), detail::expression > >::type operator&(const V& a, const number& b) { return detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), number >::type operator&(const V& a, number&& b) { return detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, detail::expression > >::type operator&(const number& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, typename detail::expression, detail::expression >::result_type >::type operator&(number&& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, number > >::type operator&(const detail::expression& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, typename detail::expression, number >::result_type >::type operator&(const detail::expression& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value == number_kind_integer, detail::expression, detail::expression > >::type operator&(const detail::expression& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value && (number_category::result_type>::value == number_kind_integer), detail::expression, V> >::type operator&(const detail::expression& a, const V& b) { return detail::expression, V>(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value && (number_category::result_type>::value == number_kind_integer), detail::expression > >::type operator&(const V& a, const detail::expression& b) { return detail::expression >(a, b); } // // Bitwise OR: // template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, number > >::type operator|(const number& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator|(number&& a, const number& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator|(const number& a, number&& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator|(number&& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), detail::expression, V> >::type operator|(const number& a, const V& b) { return detail::expression, V>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), number >::type operator|(number&& a, const V& b) { return detail::expression, V>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), detail::expression > >::type operator|(const V& a, const number& b) { return detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), number >::type operator|(const V& a, number&& b) { return detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, detail::expression > >::type operator|(const number& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, typename detail::expression, detail::expression >::result_type>::type operator|(number&& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, number > >::type operator|(const detail::expression& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, typename detail::expression, number >::result_type>::type operator|(const detail::expression& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value == number_kind_integer, detail::expression, detail::expression > >::type operator|(const detail::expression& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value && (number_category::result_type>::value == number_kind_integer), detail::expression, V> >::type operator|(const detail::expression& a, const V& b) { return detail::expression, V>(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value && (number_category::result_type>::value == number_kind_integer), detail::expression > >::type operator|(const V& a, const detail::expression& b) { return detail::expression >(a, b); } // // Bitwise XOR: // template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, number > >::type operator^(const number& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator^(number&& a, const number& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator^(const number& a, number&& b) { return detail::expression, number >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, number >::type operator^(number&& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), detail::expression, V> >::type operator^(const number& a, const V& b) { return detail::expression, V>(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), number >::type operator^(number&& a, const V& b) { return detail::expression, V>(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), detail::expression > >::type operator^(const V& a, const number& b) { return detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c >::value && (number_category::value == number_kind_integer), number >::type operator^(const V& a, number&& b) { return detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, detail::expression > >::type operator^(const number& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, typename detail::expression, detail::expression >::result_type>::type operator^(number&& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, detail::expression, number > >::type operator^(const detail::expression& a, const number& b) { return detail::expression, number >(a, b); } #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::value == number_kind_integer, typename detail::expression, number >::result_type>::type operator^(const detail::expression& a, number&& b) { return detail::expression, number >(a, b); } #endif template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value == number_kind_integer, detail::expression, detail::expression > >::type operator^(const detail::expression& a, const detail::expression& b) { return detail::expression, detail::expression >(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value && (number_category::result_type>::value == number_kind_integer), detail::expression, V> >::type operator^(const detail::expression& a, const V& b) { return detail::expression, V>(a, b); } template inline BOOST_MP_CXX14_CONSTEXPR typename enable_if_c::result_type>::value && (number_category::result_type>::value == number_kind_integer), detail::expression > >::type operator^(const V& a, const detail::expression& b) { return detail::expression >(a, b); } }} // namespace boost::multiprecision #endif