bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated boost on windows

Browse Source
This commit is contained in:
Bassem Girgis
2019-08-13 21:48:48 -05:00
parent 7d77d485fd
commit b40a3bee82
5162 changed files with 473027 additions and 116452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
winx64/include/boost/units/quantity.hpp
View File

@@ -98,17 +98,17 @@ class quantity
typedef Y value_type;
typedef Unit unit_type;
quantity() : val_()
BOOST_CONSTEXPR quantity() : val_()
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
quantity(unspecified_null_pointer_constant_type) : val_()
BOOST_CONSTEXPR quantity(unspecified_null_pointer_constant_type) : val_()
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
quantity(const this_type& source) : val_(source.val_)
BOOST_CONSTEXPR quantity(const this_type& source) : val_(source.val_)
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
@@ -124,7 +124,7 @@ class quantity
//~quantity() { }
this_type& operator=(const this_type& source)
BOOST_CXX14_CONSTEXPR this_type& operator=(const this_type& source)
{
val_ = source.val_;
@@ -135,7 +135,7 @@ class quantity
/// implicit conversion between value types is allowed if allowed for value types themselves
template<class YY>
quantity(const quantity<Unit,YY>& source,
BOOST_CONSTEXPR quantity(const quantity<Unit,YY>& source,
typename boost::enable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
val_(source.value())
{
@@ -144,7 +144,7 @@ class quantity
/// implicit conversion between value types is not allowed if not allowed for value types themselves
template<class YY>
explicit quantity(const quantity<Unit,YY>& source,
explicit BOOST_CONSTEXPR quantity(const quantity<Unit,YY>& source,
typename boost::disable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
val_(static_cast<Y>(source.value()))
{
@@ -155,7 +155,7 @@ class quantity
/// implicit conversion between value types is allowed if allowed for value types themselves
template<class YY>
quantity(const quantity<Unit,YY>& source) :
BOOST_CONSTEXPR quantity(const quantity<Unit,YY>& source) :
val_(source.value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -166,7 +166,7 @@ class quantity
/// implicit assignment between value types is allowed if allowed for value types themselves
template<class YY>
this_type& operator=(const quantity<Unit,YY>& source)
BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity<Unit,YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true));
@@ -180,7 +180,7 @@ class quantity
/// explicit conversion between different unit systems is allowed if implicit conversion is disallowed
template<class Unit2,class YY>
explicit
quantity(const quantity<Unit2,YY>& source,
BOOST_CONSTEXPR quantity(const quantity<Unit2,YY>& source,
typename boost::disable_if<
mpl::and_<
//is_implicitly_convertible should be undefined when the
@@ -198,7 +198,7 @@ class quantity
/// implicit conversion between different unit systems is allowed if each fundamental dimension is implicitly convertible
template<class Unit2,class YY>
quantity(const quantity<Unit2,YY>& source,
BOOST_CONSTEXPR quantity(const quantity<Unit2,YY>& source,
typename boost::enable_if<
mpl::and_<
typename is_implicitly_convertible<Unit2,Unit>::type,
@@ -217,7 +217,7 @@ class quantity
/// without SFINAE we can't distinguish between explicit and implicit conversions so
/// the conversion is always explicit
template<class Unit2,class YY>
explicit quantity(const quantity<Unit2,YY>& source)
explicit BOOST_CONSTEXPR quantity(const quantity<Unit2,YY>& source)
: val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -228,7 +228,7 @@ class quantity
/// implicit assignment between different unit systems is allowed if each fundamental dimension is implicitly convertible
template<class Unit2,class YY>
this_type& operator=(const quantity<Unit2,YY>& source)
BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity<Unit2,YY>& source)
{
BOOST_STATIC_ASSERT((is_implicitly_convertible<Unit2,unit_type>::value == true));
@@ -239,11 +239,11 @@ class quantity
return *this;
}
const value_type& value() const { return val_; } ///< constant accessor to value
BOOST_CONSTEXPR const value_type& value() const { return val_; } ///< constant accessor to value
///< can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type
template<class Unit2, class YY>
this_type& operator+=(const quantity<Unit2, YY>& source)
BOOST_CXX14_CONSTEXPR this_type& operator+=(const quantity<Unit2, YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_same<typename add_typeof_helper<Unit, Unit2>::type, Unit>::value));
val_ += source.value();
@@ -252,7 +252,7 @@ class quantity
///< can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type
template<class Unit2, class YY>
this_type& operator-=(const quantity<Unit2, YY>& source)
BOOST_CXX14_CONSTEXPR this_type& operator-=(const quantity<Unit2, YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_same<typename subtract_typeof_helper<Unit, Unit2>::type, Unit>::value));
val_ -= source.value();
@@ -260,7 +260,7 @@ class quantity
}
template<class Unit2, class YY>
this_type& operator*=(const quantity<Unit2, YY>& source)
BOOST_CXX14_CONSTEXPR this_type& operator*=(const quantity<Unit2, YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_same<typename multiply_typeof_helper<Unit, Unit2>::type, Unit>::value));
val_ *= source.value();
@@ -268,7 +268,7 @@ class quantity
}
template<class Unit2, class YY>
this_type& operator/=(const quantity<Unit2, YY>& source)
BOOST_CXX14_CONSTEXPR this_type& operator/=(const quantity<Unit2, YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_same<typename divide_typeof_helper<Unit, Unit2>::type, Unit>::value));
val_ /= source.value();
@@ -276,15 +276,15 @@ class quantity
}
///< can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type
this_type& operator*=(const value_type& source) { val_ *= source; return *this; }
BOOST_CXX14_CONSTEXPR this_type& operator*=(const value_type& source) { val_ *= source; return *this; }
///< can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
this_type& operator/=(const value_type& source) { val_ /= source; return *this; }
BOOST_CXX14_CONSTEXPR this_type& operator/=(const value_type& source) { val_ /= source; return *this; }
/// Construct quantity directly from @c value_type (potentially dangerous).
static this_type from_value(const value_type& val) { return this_type(val, 0); }
static BOOST_CONSTEXPR this_type from_value(const value_type& val) { return this_type(val, 0); }
protected:
explicit quantity(const value_type& val, int) : val_(val) { }
explicit BOOST_CONSTEXPR quantity(const value_type& val, int) : val_(val) { }
private:
value_type val_;
@@ -305,25 +305,25 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
typedef dimensionless_type dimension_type;
typedef unit<dimension_type,system_type> unit_type;
quantity() : val_()
BOOST_CONSTEXPR quantity() : val_()
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
/// construction from raw @c value_type is allowed
quantity(value_type val) : val_(val)
BOOST_CONSTEXPR quantity(value_type val) : val_(val)
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
quantity(const this_type& source) : val_(source.val_)
BOOST_CONSTEXPR quantity(const this_type& source) : val_(source.val_)
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
//~quantity() { }
this_type& operator=(const this_type& source)
BOOST_CXX14_CONSTEXPR this_type& operator=(const this_type& source)
{
val_ = source.val_;
@@ -334,7 +334,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between value types is allowed if allowed for value types themselves
template<class YY>
quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
BOOST_CONSTEXPR quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
typename boost::enable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
val_(source.value())
{
@@ -343,7 +343,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between value types is not allowed if not allowed for value types themselves
template<class YY>
explicit quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
explicit BOOST_CONSTEXPR quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
typename boost::disable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
val_(static_cast<Y>(source.value()))
{
@@ -354,7 +354,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between value types is allowed if allowed for value types themselves
template<class YY>
quantity(const quantity<unit<dimension_type,system_type>,YY>& source) :
BOOST_CONSTEXPR quantity(const quantity<unit<dimension_type,system_type>,YY>& source) :
val_(source.value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -365,7 +365,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit assignment between value types is allowed if allowed for value types themselves
template<class YY>
this_type& operator=(const quantity<unit<dimension_type,system_type>,YY>& source)
BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity<unit<dimension_type,system_type>,YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
@@ -378,7 +378,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between different unit systems is allowed
template<class System2, class Y2>
quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
BOOST_CONSTEXPR quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
#ifdef __SUNPRO_CC
typename boost::enable_if<
boost::mpl::and_<
@@ -399,7 +399,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between different unit systems is allowed
template<class System2, class Y2>
explicit quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
explicit BOOST_CONSTEXPR quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
#ifdef __SUNPRO_CC
typename boost::enable_if<
boost::mpl::and_<
@@ -422,7 +422,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between different unit systems is allowed
template<class System2, class Y2>
quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source) :
BOOST_CONSTEXPR quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source) :
val_(source.value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -434,7 +434,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// conversion between different unit systems is explicit when
/// the units are not equivalent.
template<class System2, class Y2>
explicit quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
explicit BOOST_CONSTEXPR quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
typename boost::disable_if<detail::is_dimensionless_system<System2> >::type* = 0) :
val_(conversion_helper<quantity<unit<dimensionless_type, System2>,Y2>, this_type>::convert(source).value())
{
@@ -445,7 +445,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit assignment between different unit systems is allowed
template<class System2>
this_type& operator=(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y>& source)
BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y>& source)
{
*this = this_type(source);
@@ -455,24 +455,24 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
#endif
/// implicit conversion to @c value_type is allowed
operator value_type() const { return val_; }
BOOST_CONSTEXPR operator value_type() const { return val_; }
const value_type& value() const { return val_; } ///< constant accessor to value
BOOST_CONSTEXPR const value_type& value() const { return val_; } ///< constant accessor to value
///< can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type
this_type& operator+=(const this_type& source) { val_ += source.val_; return *this; }
BOOST_CXX14_CONSTEXPR this_type& operator+=(const this_type& source) { val_ += source.val_; return *this; }
///< can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type
this_type& operator-=(const this_type& source) { val_ -= source.val_; return *this; }
BOOST_CXX14_CONSTEXPR this_type& operator-=(const this_type& source) { val_ -= source.val_; return *this; }
///< can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type
this_type& operator*=(const value_type& val) { val_ *= val; return *this; }
BOOST_CXX14_CONSTEXPR this_type& operator*=(const value_type& val) { val_ *= val; return *this; }
///< can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
this_type& operator/=(const value_type& val) { val_ /= val; return *this; }
BOOST_CXX14_CONSTEXPR this_type& operator/=(const value_type& val) { val_ /= val; return *this; }
/// Construct quantity directly from @c value_type.
static this_type from_value(const value_type& val) { return this_type(val); }
static BOOST_CONSTEXPR this_type from_value(const value_type& val) { return this_type(val); }
private:
value_type val_;
@@ -513,7 +513,7 @@ struct quantity_cast_helper<Y,quantity<Unit,X> >
{
typedef Y type;
type operator()(quantity<Unit,X>& source) { return const_cast<X&>(source.value()); }
BOOST_CONSTEXPR type operator()(quantity<Unit,X>& source) const { return const_cast<X&>(source.value()); }
};
/// specialization for casting to the value type
@@ -522,7 +522,7 @@ struct quantity_cast_helper<Y,const quantity<Unit,X> >
{
typedef Y type;
type operator()(const quantity<Unit,X>& source) { return source.value(); }
BOOST_CONSTEXPR type operator()(const quantity<Unit,X>& source) const { return source.value(); }
};
} // namespace detail
@@ -530,22 +530,20 @@ struct quantity_cast_helper<Y,const quantity<Unit,X> >
/// quantity_cast provides mutating access to underlying quantity value_type
template<class X,class Y>
inline
BOOST_CONSTEXPR
X
quantity_cast(Y& source)
{
detail::quantity_cast_helper<X,Y> qch;
return qch(source);
return detail::quantity_cast_helper<X,Y>()(source);
}
template<class X,class Y>
inline
BOOST_CONSTEXPR
X
quantity_cast(const Y& source)
{
detail::quantity_cast_helper<X,const Y> qch;
return qch(source);
return detail::quantity_cast_helper<X,const Y>()(source);
}
/// swap quantities
@@ -863,7 +861,7 @@ struct power_typeof_helper< quantity<Unit,Y>,static_rational<N,D> >
typedef typename power_typeof_helper<Unit,static_rational<N,D> >::type unit_type;
typedef quantity<unit_type,value_type> type;
static type value(const quantity<Unit,Y>& x)
static BOOST_CONSTEXPR type value(const quantity<Unit,Y>& x)
{
return type::from_value(power_typeof_helper<Y,static_rational<N,D> >::value(x.value()));
}
@@ -878,7 +876,7 @@ struct root_typeof_helper< quantity<Unit,Y>,static_rational<N,D> >
typedef typename root_typeof_helper<Unit,static_rational<N,D> >::type unit_type;
typedef quantity<unit_type,value_type> type;
static type value(const quantity<Unit,Y>& x)
static BOOST_CONSTEXPR type value(const quantity<Unit,Y>& x)
{
return type::from_value(root_typeof_helper<Y,static_rational<N,D> >::value(x.value()));
}
@@ -890,6 +888,7 @@ template<class System,
class Dim,
class Y>
inline
BOOST_CONSTEXPR
typename multiply_typeof_helper< unit<Dim,System>,Y >::type
operator*(const unit<Dim,System>&,const Y& rhs)
{
@@ -903,6 +902,7 @@ template<class System,
class Dim,
class Y>
inline
BOOST_CONSTEXPR
typename divide_typeof_helper< unit<Dim,System>,Y >::type
operator/(const unit<Dim,System>&,const Y& rhs)
{
@@ -916,6 +916,7 @@ template<class System,
class Dim,
class Y>
inline
BOOST_CONSTEXPR
typename multiply_typeof_helper< Y,unit<Dim,System> >::type
operator*(const Y& lhs,const unit<Dim,System>&)
{
@@ -929,6 +930,7 @@ template<class System,
class Dim,
class Y>
inline
BOOST_CONSTEXPR
typename divide_typeof_helper< Y,unit<Dim,System> >::type
operator/(const Y& lhs,const unit<Dim,System>&)
{
@@ -942,6 +944,7 @@ operator/(const Y& lhs,const unit<Dim,System>&)
// class X,
// class Y>
//inline
//BOOST_CONSTEXPR
//typename multiply_typeof_helper< quantity<Unit,X>,Y >::type
//operator*(const quantity<Unit,X>& lhs,const Y& rhs)
//{
@@ -955,6 +958,7 @@ operator/(const Y& lhs,const unit<Dim,System>&)
// class X,
// class Y>
//inline
//BOOST_CONSTEXPR
//typename multiply_typeof_helper< X,quantity<Unit,Y> >::type
//operator*(const X& lhs,const quantity<Unit,Y>& rhs)
//{
@@ -967,6 +971,7 @@ operator/(const Y& lhs,const unit<Dim,System>&)
template<class Unit,
class X>
inline
BOOST_CONSTEXPR
typename multiply_typeof_helper< quantity<Unit,X>,X >::type
operator*(const quantity<Unit,X>& lhs,const X& rhs)
{
@@ -979,6 +984,7 @@ operator*(const quantity<Unit,X>& lhs,const X& rhs)
template<class Unit,
class X>
inline
BOOST_CONSTEXPR
typename multiply_typeof_helper< X,quantity<Unit,X> >::type
operator*(const X& lhs,const quantity<Unit,X>& rhs)
{
@@ -992,6 +998,7 @@ operator*(const X& lhs,const quantity<Unit,X>& rhs)
// class X,
// class Y>
//inline
//BOOST_CONSTEXPR
//typename divide_typeof_helper< quantity<Unit,X>,Y >::type
//operator/(const quantity<Unit,X>& lhs,const Y& rhs)
//{
@@ -1005,6 +1012,7 @@ operator*(const X& lhs,const quantity<Unit,X>& rhs)
// class X,
// class Y>
//inline
//BOOST_CONSTEXPR
//typename divide_typeof_helper< X,quantity<Unit,Y> >::type
//operator/(const X& lhs,const quantity<Unit,Y>& rhs)
//{
@@ -1017,6 +1025,7 @@ operator*(const X& lhs,const quantity<Unit,X>& rhs)
template<class Unit,
class X>
inline
BOOST_CONSTEXPR
typename divide_typeof_helper< quantity<Unit,X>,X >::type
operator/(const quantity<Unit,X>& lhs,const X& rhs)
{
@@ -1029,6 +1038,7 @@ operator/(const quantity<Unit,X>& lhs,const X& rhs)
template<class Unit,
class X>
inline
BOOST_CONSTEXPR
typename divide_typeof_helper< X,quantity<Unit,X> >::type
operator/(const X& lhs,const quantity<Unit,X>& rhs)
{
@@ -1043,6 +1053,7 @@ template<class System1,
class Unit2,
class Y>
inline
BOOST_CONSTEXPR
typename multiply_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type
operator*(const unit<Dim1,System1>&,const quantity<Unit2,Y>& rhs)
{
@@ -1057,6 +1068,7 @@ template<class System1,
class Unit2,
class Y>
inline
BOOST_CONSTEXPR
typename divide_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type
operator/(const unit<Dim1,System1>&,const quantity<Unit2,Y>& rhs)
{
@@ -1071,6 +1083,7 @@ template<class Unit1,
class Dim2,
class Y>
inline
BOOST_CONSTEXPR
typename multiply_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type
operator*(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&)
{
@@ -1085,6 +1098,7 @@ template<class Unit1,
class Dim2,
class Y>
inline
BOOST_CONSTEXPR
typename divide_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type
operator/(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&)
{
@@ -1095,6 +1109,7 @@ operator/(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&)
/// runtime unary plus quantity
template<class Unit,class Y>
BOOST_CONSTEXPR
typename unary_plus_typeof_helper< quantity<Unit,Y> >::type
operator+(const quantity<Unit,Y>& val)
{
@@ -1105,6 +1120,7 @@ operator+(const quantity<Unit,Y>& val)
/// runtime unary minus quantity
template<class Unit,class Y>
BOOST_CONSTEXPR
typename unary_minus_typeof_helper< quantity<Unit,Y> >::type
operator-(const quantity<Unit,Y>& val)
{
@@ -1119,6 +1135,7 @@ template<class Unit1,
class X,
class Y>
inline
BOOST_CONSTEXPR
typename add_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
operator+(const quantity<Unit1,X>& lhs,
const quantity<Unit2,Y>& rhs)
@@ -1134,6 +1151,7 @@ template<class Unit1,
class X,
class Y>
inline
BOOST_CONSTEXPR
typename subtract_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
operator-(const quantity<Unit1,X>& lhs,
const quantity<Unit2,Y>& rhs)
@@ -1149,6 +1167,7 @@ template<class Unit1,
class X,
class Y>
inline
BOOST_CONSTEXPR
typename multiply_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
operator*(const quantity<Unit1,X>& lhs,
const quantity<Unit2,Y>& rhs)
@@ -1165,6 +1184,7 @@ template<class Unit1,
class X,
class Y>
inline
BOOST_CONSTEXPR
typename divide_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
operator/(const quantity<Unit1,X>& lhs,
const quantity<Unit2,Y>& rhs)
@@ -1180,6 +1200,7 @@ template<class Unit,
class X,
class Y>
inline
BOOST_CONSTEXPR
bool
operator==(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1192,6 +1213,7 @@ template<class Unit,
class X,
class Y>
inline
BOOST_CONSTEXPR
bool
operator!=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1204,6 +1226,7 @@ template<class Unit,
class X,
class Y>
inline
BOOST_CONSTEXPR
bool
operator<(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1216,6 +1239,7 @@ template<class Unit,
class X,
class Y>
inline
BOOST_CONSTEXPR
bool
operator<=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1228,6 +1252,7 @@ template<class Unit,
class X,
class Y>
inline
BOOST_CONSTEXPR
bool
operator>(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1240,6 +1265,7 @@ template<class Unit,
class X,
class Y>
inline
BOOST_CONSTEXPR
bool
operator>=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)