| // Boost.Units - A C++ library for zero-overhead dimensional analysis and |
| // unit/quantity manipulation and conversion |
| // |
| // Copyright (C) 2003-2008 Matthias Christian Schabel |
| // Copyright (C) 2007-2008 Steven Watanabe |
| // |
| // 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_UNITS_QUANTITY_HPP |
| #define BOOST_UNITS_QUANTITY_HPP |
| |
| #include <algorithm> |
| |
| #include <boost/config.hpp> |
| #include <boost/static_assert.hpp> |
| #include <boost/mpl/bool.hpp> |
| #include <boost/mpl/and.hpp> |
| #include <boost/mpl/not.hpp> |
| #include <boost/mpl/or.hpp> |
| #include <boost/mpl/assert.hpp> |
| #include <boost/utility/enable_if.hpp> |
| #include <boost/type_traits/is_arithmetic.hpp> |
| #include <boost/type_traits/is_convertible.hpp> |
| #include <boost/type_traits/is_integral.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| |
| #include <boost/units/conversion.hpp> |
| #include <boost/units/dimensionless_type.hpp> |
| #include <boost/units/homogeneous_system.hpp> |
| #include <boost/units/operators.hpp> |
| #include <boost/units/static_rational.hpp> |
| #include <boost/units/units_fwd.hpp> |
| #include <boost/units/detail/dimensionless_unit.hpp> |
| |
| namespace boost { |
| |
| namespace units { |
| |
| namespace detail { |
| |
| template<class T, class Enable = void> |
| struct is_base_unit : mpl::false_ {}; |
| |
| template<class T> |
| struct is_base_unit<T, typename T::boost_units_is_base_unit_type> : mpl::true_ {}; |
| |
| template<class Source, class Destination> |
| struct is_narrowing_conversion_impl : mpl::bool_<(sizeof(Source) > sizeof(Destination))> {}; |
| |
| template<class Source, class Destination> |
| struct is_non_narrowing_conversion : |
| mpl::and_< |
| boost::is_convertible<Source, Destination>, |
| mpl::not_< |
| mpl::and_< |
| boost::is_arithmetic<Source>, |
| boost::is_arithmetic<Destination>, |
| mpl::or_< |
| mpl::and_< |
| is_integral<Destination>, |
| mpl::not_<is_integral<Source> > |
| >, |
| is_narrowing_conversion_impl<Source, Destination> |
| > |
| > |
| > |
| > |
| {}; |
| |
| template<> |
| struct is_non_narrowing_conversion<long double, double> : mpl::false_ {}; |
| |
| // msvc 7.1 needs extra disambiguation |
| template<class T, class U> |
| struct disable_if_is_same |
| { |
| typedef void type; |
| }; |
| |
| template<class T> |
| struct disable_if_is_same<T, T> {}; |
| |
| } |
| |
| /// class declaration |
| template<class Unit,class Y = double> |
| class quantity |
| { |
| // base units are not the same as units. |
| BOOST_MPL_ASSERT_NOT((detail::is_base_unit<Unit>)); |
| enum { force_instantiation_of_unit = sizeof(Unit) }; |
| typedef void (quantity::*unspecified_null_pointer_constant_type)(int*******); |
| public: |
| typedef quantity<Unit,Y> this_type; |
| |
| typedef Y value_type; |
| typedef Unit unit_type; |
| |
| quantity() : val_() |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| quantity(unspecified_null_pointer_constant_type) : val_() |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| quantity(const this_type& source) : val_(source.val_) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| // Need to make sure that the destructor of |
| // Unit which contains the checking is instantiated, |
| // on sun. |
| #ifdef __SUNPRO_CC |
| ~quantity() { |
| unit_type force_unit_instantiation; |
| } |
| #endif |
| |
| //~quantity() { } |
| |
| this_type& operator=(const this_type& source) |
| { |
| val_ = source.val_; |
| |
| return *this; |
| } |
| |
| #ifndef BOOST_NO_SFINAE |
| |
| /// implicit conversion between value types is allowed if allowed for value types themselves |
| template<class YY> |
| quantity(const quantity<Unit,YY>& source, |
| typename boost::enable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) : |
| val_(source.value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| /// 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, |
| typename boost::disable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) : |
| val_(static_cast<Y>(source.value())) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| #else |
| |
| /// implicit conversion between value types is allowed if allowed for value types themselves |
| template<class YY> |
| quantity(const quantity<Unit,YY>& source) : |
| val_(source.value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| BOOST_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true)); |
| } |
| |
| #endif |
| |
| /// 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_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true)); |
| |
| *this = this_type(source); |
| |
| return *this; |
| } |
| |
| #ifndef BOOST_NO_SFINAE |
| |
| /// 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, |
| typename boost::disable_if< |
| mpl::and_< |
| //is_implicitly_convertible should be undefined when the |
| //units are not convertible at all |
| typename is_implicitly_convertible<Unit2,Unit>::type, |
| detail::is_non_narrowing_conversion<YY, Y> |
| >, |
| typename detail::disable_if_is_same<Unit, Unit2>::type |
| >::type* = 0) |
| : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true)); |
| } |
| |
| /// 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, |
| typename boost::enable_if< |
| mpl::and_< |
| typename is_implicitly_convertible<Unit2,Unit>::type, |
| detail::is_non_narrowing_conversion<YY, Y> |
| >, |
| typename detail::disable_if_is_same<Unit, Unit2>::type |
| >::type* = 0) |
| : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true)); |
| } |
| |
| #else |
| |
| /// 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) |
| : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true)); |
| } |
| |
| #endif |
| |
| /// 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_STATIC_ASSERT((is_implicitly_convertible<Unit2,unit_type>::value == true)); |
| BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true)); |
| |
| *this = this_type(source); |
| |
| return *this; |
| } |
| |
| 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_STATIC_ASSERT((boost::is_same<typename add_typeof_helper<Unit, Unit2>::type, Unit>::value)); |
| val_ += source.value(); |
| return *this; |
| } |
| |
| ///< 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_STATIC_ASSERT((boost::is_same<typename subtract_typeof_helper<Unit, Unit2>::type, Unit>::value)); |
| val_ -= source.value(); |
| return *this; |
| } |
| |
| template<class Unit2, class YY> |
| 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(); |
| return *this; |
| } |
| |
| template<class Unit2, class YY> |
| 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(); |
| 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& 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; } |
| |
| /// Construct quantity directly from @c value_type (potentially dangerous). |
| static this_type from_value(const value_type& val) { return this_type(val, 0); } |
| |
| protected: |
| explicit quantity(const value_type& val, int) : val_(val) { } |
| |
| private: |
| value_type val_; |
| }; |
| |
| /// Specialization for dimensionless quantities. Implicit conversions between |
| /// unit systems are allowed because all dimensionless quantities are equivalent. |
| /// Implicit construction and assignment from and conversion to @c value_type is |
| /// also allowed. |
| template<class System,class Y> |
| class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y> |
| { |
| public: |
| typedef quantity<unit<dimensionless_type,System>,Y> this_type; |
| |
| typedef Y value_type; |
| typedef System system_type; |
| typedef dimensionless_type dimension_type; |
| typedef unit<dimension_type,system_type> unit_type; |
| |
| 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_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| quantity(const this_type& source) : val_(source.val_) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| //~quantity() { } |
| |
| this_type& operator=(const this_type& source) |
| { |
| val_ = source.val_; |
| |
| return *this; |
| } |
| |
| #ifndef BOOST_NO_SFINAE |
| |
| /// 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, |
| typename boost::enable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) : |
| val_(source.value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, 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, |
| typename boost::disable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) : |
| val_(static_cast<Y>(source.value())) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| #else |
| |
| /// 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) : |
| val_(source.value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| BOOST_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true)); |
| } |
| |
| #endif |
| |
| /// 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_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true)); |
| |
| *this = this_type(source); |
| |
| return *this; |
| } |
| |
| #if 1 |
| |
| /// implicit conversion between different unit systems is allowed |
| template<class System2, class Y2> |
| quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source, |
| #ifdef __SUNPRO_CC |
| typename boost::enable_if< |
| boost::mpl::and_< |
| detail::is_non_narrowing_conversion<Y2, Y>, |
| detail::is_dimensionless_system<System2> |
| > |
| >::type* = 0 |
| #else |
| typename boost::enable_if<detail::is_non_narrowing_conversion<Y2, Y> >::type* = 0, |
| typename detail::disable_if_is_same<System, System2>::type* = 0, |
| typename boost::enable_if<detail::is_dimensionless_system<System2> >::type* = 0 |
| #endif |
| ) : |
| val_(source.value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| /// implicit conversion between different unit systems is allowed |
| template<class System2, class Y2> |
| explicit quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source, |
| #ifdef __SUNPRO_CC |
| typename boost::enable_if< |
| boost::mpl::and_< |
| boost::mpl::not_<detail::is_non_narrowing_conversion<Y2, Y> >, |
| detail::is_dimensionless_system<System2> |
| > |
| >::type* = 0 |
| #else |
| typename boost::disable_if<detail::is_non_narrowing_conversion<Y2, Y> >::type* = 0, |
| typename detail::disable_if_is_same<System, System2>::type* = 0, |
| typename boost::enable_if<detail::is_dimensionless_system<System2> >::type* = 0 |
| #endif |
| ) : |
| val_(static_cast<Y>(source.value())) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| #else |
| |
| /// implicit conversion between different unit systems is allowed |
| template<class System2, class Y2> |
| quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source) : |
| val_(source.value()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| BOOST_STATIC_ASSERT((boost::is_convertible<Y2, Y>::value == true)); |
| } |
| |
| #endif |
| |
| /// 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, |
| 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()) |
| { |
| BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); |
| } |
| |
| #ifndef __SUNPRO_CC |
| |
| /// implicit assignment between different unit systems is allowed |
| template<class System2> |
| this_type& operator=(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y>& source) |
| { |
| *this = this_type(source); |
| |
| return *this; |
| } |
| |
| #endif |
| |
| /// implicit conversion to @c value_type is allowed |
| operator value_type() const { return val_; } |
| |
| 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; } |
| |
| ///< 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; } |
| |
| ///< 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; } |
| |
| ///< 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; } |
| |
| /// Construct quantity directly from @c value_type. |
| static this_type from_value(const value_type& val) { return this_type(val); } |
| |
| private: |
| value_type val_; |
| }; |
| |
| #ifdef BOOST_MSVC |
| // HACK: For some obscure reason msvc 8.0 needs these specializations |
| template<class System, class T> |
| class quantity<unit<int, System>, T> {}; |
| template<class T> |
| class quantity<int, T> {}; |
| #endif |
| |
| } // namespace units |
| |
| } // namespace boost |
| |
| #if BOOST_UNITS_HAS_BOOST_TYPEOF |
| |
| #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() |
| |
| BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::quantity, 2) |
| |
| #endif |
| |
| namespace boost { |
| |
| namespace units { |
| |
| namespace detail { |
| |
| /// helper class for quantity_cast |
| template<class X,class Y> struct quantity_cast_helper; |
| |
| /// specialization for casting to the value type |
| template<class Y,class X,class Unit> |
| struct quantity_cast_helper<Y,quantity<Unit,X> > |
| { |
| typedef Y type; |
| |
| type operator()(quantity<Unit,X>& source) { return const_cast<X&>(source.value()); } |
| }; |
| |
| /// specialization for casting to the value type |
| template<class Y,class X,class Unit> |
| struct quantity_cast_helper<Y,const quantity<Unit,X> > |
| { |
| typedef Y type; |
| |
| type operator()(const quantity<Unit,X>& source) { return source.value(); } |
| }; |
| |
| } // namespace detail |
| |
| /// quantity_cast provides mutating access to underlying quantity value_type |
| template<class X,class Y> |
| inline |
| X |
| quantity_cast(Y& source) |
| { |
| detail::quantity_cast_helper<X,Y> qch; |
| |
| return qch(source); |
| } |
| |
| template<class X,class Y> |
| inline |
| X |
| quantity_cast(const Y& source) |
| { |
| detail::quantity_cast_helper<X,const Y> qch; |
| |
| return qch(source); |
| } |
| |
| /// swap quantities |
| template<class Unit,class Y> |
| inline void swap(quantity<Unit,Y>& lhs, quantity<Unit,Y>& rhs) |
| { |
| using std::swap; |
| swap(quantity_cast<Y&>(lhs),quantity_cast<Y&>(rhs)); |
| } |
| |
| /// specialize unary plus typeof helper |
| /// INTERNAL ONLY |
| template<class Unit,class Y> |
| struct unary_plus_typeof_helper< quantity<Unit,Y> > |
| { |
| typedef typename unary_plus_typeof_helper<Y>::type value_type; |
| typedef typename unary_plus_typeof_helper<Unit>::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// specialize unary minus typeof helper |
| /// INTERNAL ONLY |
| template<class Unit,class Y> |
| struct unary_minus_typeof_helper< quantity<Unit,Y> > |
| { |
| typedef typename unary_minus_typeof_helper<Y>::type value_type; |
| typedef typename unary_minus_typeof_helper<Unit>::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// specialize add typeof helper |
| /// INTERNAL ONLY |
| template<class Unit1, |
| class Unit2, |
| class X, |
| class Y> |
| struct add_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> > |
| { |
| typedef typename add_typeof_helper<X,Y>::type value_type; |
| typedef typename add_typeof_helper<Unit1,Unit2>::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// for sun CC we need to invoke SFINAE at |
| /// the top level, otherwise it will silently |
| /// return int. |
| template<class Dim1, class System1, |
| class Dim2, class System2, |
| class X, |
| class Y> |
| struct add_typeof_helper< quantity<unit<Dim1, System1>,X>,quantity<unit<Dim2, System2>,Y> > |
| { |
| }; |
| |
| template<class Dim, |
| class System, |
| class X, |
| class Y> |
| struct add_typeof_helper< quantity<unit<Dim, System>,X>,quantity<unit<Dim, System>,Y> > |
| { |
| typedef typename add_typeof_helper<X,Y>::type value_type; |
| typedef unit<Dim, System> unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// specialize subtract typeof helper |
| /// INTERNAL ONLY |
| template<class Unit1, |
| class Unit2, |
| class X, |
| class Y> |
| struct subtract_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> > |
| { |
| typedef typename subtract_typeof_helper<X,Y>::type value_type; |
| typedef typename subtract_typeof_helper<Unit1,Unit2>::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| // Force adding different units to fail on sun. |
| template<class Dim1, class System1, |
| class Dim2, class System2, |
| class X, |
| class Y> |
| struct subtract_typeof_helper< quantity<unit<Dim1, System1>,X>,quantity<unit<Dim2, System2>,Y> > |
| { |
| }; |
| |
| template<class Dim, |
| class System, |
| class X, |
| class Y> |
| struct subtract_typeof_helper< quantity<unit<Dim, System>,X>,quantity<unit<Dim, System>,Y> > |
| { |
| typedef typename subtract_typeof_helper<X,Y>::type value_type; |
| typedef unit<Dim, System> unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// scalar times unit typeof helper |
| /// INTERNAL ONLY |
| template<class System, |
| class Dim, |
| class X> |
| struct multiply_typeof_helper< X,unit<Dim,System> > |
| { |
| typedef X value_type; |
| typedef unit<Dim,System> unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// unit times scalar typeof helper |
| /// INTERNAL ONLY |
| template<class System, |
| class Dim, |
| class X> |
| struct multiply_typeof_helper< unit<Dim,System>,X > |
| { |
| typedef X value_type; |
| typedef unit<Dim,System> unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// scalar times quantity typeof helper |
| /// INTERNAL ONLY |
| template<class Unit, |
| class X, |
| class Y> |
| struct multiply_typeof_helper< X,quantity<Unit,Y> > |
| { |
| typedef typename multiply_typeof_helper<X,Y>::type value_type; |
| typedef Unit unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// quantity times scalar typeof helper |
| /// INTERNAL ONLY |
| template<class Unit, |
| class X, |
| class Y> |
| struct multiply_typeof_helper< quantity<Unit,X>,Y > |
| { |
| typedef typename multiply_typeof_helper<X,Y>::type value_type; |
| typedef Unit unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// unit times quantity typeof helper |
| /// INTERNAL ONLY |
| template<class Unit, |
| class System, |
| class Dim, |
| class X> |
| struct multiply_typeof_helper< unit<Dim,System>,quantity<Unit,X> > |
| { |
| typedef X value_type; |
| typedef typename multiply_typeof_helper< unit<Dim,System>,Unit >::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// quantity times unit typeof helper |
| /// INTERNAL ONLY |
| template<class Unit, |
| class System, |
| class Dim, |
| class X> |
| struct multiply_typeof_helper< quantity<Unit,X>,unit<Dim,System> > |
| { |
| typedef X value_type; |
| typedef typename multiply_typeof_helper< Unit,unit<Dim,System> >::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// quantity times quantity typeof helper |
| /// INTERNAL ONLY |
| template<class Unit1, |
| class Unit2, |
| class X, |
| class Y> |
| struct multiply_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> > |
| { |
| typedef typename multiply_typeof_helper<X,Y>::type value_type; |
| typedef typename multiply_typeof_helper<Unit1,Unit2>::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// scalar divided by unit typeof helper |
| /// INTERNAL ONLY |
| template<class System, |
| class Dim, |
| class X> |
| struct divide_typeof_helper< X,unit<Dim,System> > |
| { |
| typedef X value_type; |
| typedef typename power_typeof_helper< unit<Dim,System>,static_rational<-1> >::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// unit divided by scalar typeof helper |
| /// INTERNAL ONLY |
| template<class System, |
| class Dim, |
| class X> |
| struct divide_typeof_helper< unit<Dim,System>,X > |
| { |
| typedef typename divide_typeof_helper<X,X>::type value_type; |
| typedef unit<Dim,System> unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// scalar divided by quantity typeof helper |
| /// INTERNAL ONLY |
| template<class Unit, |
| class X, |
| class Y> |
| struct divide_typeof_helper< X,quantity<Unit,Y> > |
| { |
| typedef typename divide_typeof_helper<X,Y>::type value_type; |
| typedef typename power_typeof_helper< Unit,static_rational<-1> >::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// quantity divided by scalar typeof helper |
| /// INTERNAL ONLY |
| template<class Unit, |
| class X, |
| class Y> |
| struct divide_typeof_helper< quantity<Unit,X>,Y > |
| { |
| typedef typename divide_typeof_helper<X,Y>::type value_type; |
| typedef Unit unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// unit divided by quantity typeof helper |
| /// INTERNAL ONLY |
| template<class Unit, |
| class System, |
| class Dim, |
| class X> |
| struct divide_typeof_helper< unit<Dim,System>,quantity<Unit,X> > |
| { |
| typedef typename divide_typeof_helper<X,X>::type value_type; |
| typedef typename divide_typeof_helper< unit<Dim,System>,Unit >::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// quantity divided by unit typeof helper |
| /// INTERNAL ONLY |
| template<class Unit, |
| class System, |
| class Dim, |
| class X> |
| struct divide_typeof_helper< quantity<Unit,X>,unit<Dim,System> > |
| { |
| typedef X value_type; |
| typedef typename divide_typeof_helper< Unit,unit<Dim,System> >::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// quantity divided by quantity typeof helper |
| /// INTERNAL ONLY |
| template<class Unit1, |
| class Unit2, |
| class X, |
| class Y> |
| struct divide_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> > |
| { |
| typedef typename divide_typeof_helper<X,Y>::type value_type; |
| typedef typename divide_typeof_helper<Unit1,Unit2>::type unit_type; |
| typedef quantity<unit_type,value_type> type; |
| }; |
| |
| /// specialize power typeof helper |
| /// INTERNAL ONLY |
| template<class Unit,long N,long D,class Y> |
| struct power_typeof_helper< quantity<Unit,Y>,static_rational<N,D> > |
| { |
| typedef typename power_typeof_helper<Y,static_rational<N,D> >::type value_type; |
| 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) |
| { |
| return type::from_value(power_typeof_helper<Y,static_rational<N,D> >::value(x.value())); |
| } |
| }; |
| |
| /// specialize root typeof helper |
| /// INTERNAL ONLY |
| template<class Unit,long N,long D,class Y> |
| struct root_typeof_helper< quantity<Unit,Y>,static_rational<N,D> > |
| { |
| typedef typename root_typeof_helper<Y,static_rational<N,D> >::type value_type; |
| 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) |
| { |
| return type::from_value(root_typeof_helper<Y,static_rational<N,D> >::value(x.value())); |
| } |
| }; |
| |
| /// runtime unit times scalar |
| /// INTERNAL ONLY |
| template<class System, |
| class Dim, |
| class Y> |
| inline |
| typename multiply_typeof_helper< unit<Dim,System>,Y >::type |
| operator*(const unit<Dim,System>&,const Y& rhs) |
| { |
| typedef typename multiply_typeof_helper< unit<Dim,System>,Y >::type type; |
| |
| return type::from_value(rhs); |
| } |
| |
| /// runtime unit divided by scalar |
| template<class System, |
| class Dim, |
| class Y> |
| inline |
| typename divide_typeof_helper< unit<Dim,System>,Y >::type |
| operator/(const unit<Dim,System>&,const Y& rhs) |
| { |
| typedef typename divide_typeof_helper<unit<Dim,System>,Y>::type type; |
| |
| return type::from_value(Y(1)/rhs); |
| } |
| |
| /// runtime scalar times unit |
| template<class System, |
| class Dim, |
| class Y> |
| inline |
| typename multiply_typeof_helper< Y,unit<Dim,System> >::type |
| operator*(const Y& lhs,const unit<Dim,System>&) |
| { |
| typedef typename multiply_typeof_helper< Y,unit<Dim,System> >::type type; |
| |
| return type::from_value(lhs); |
| } |
| |
| /// runtime scalar divided by unit |
| template<class System, |
| class Dim, |
| class Y> |
| inline |
| typename divide_typeof_helper< Y,unit<Dim,System> >::type |
| operator/(const Y& lhs,const unit<Dim,System>&) |
| { |
| typedef typename divide_typeof_helper< Y,unit<Dim,System> >::type type; |
| |
| return type::from_value(lhs); |
| } |
| |
| ///// runtime quantity times scalar |
| //template<class Unit, |
| // class X, |
| // class Y> |
| //inline |
| //typename multiply_typeof_helper< quantity<Unit,X>,Y >::type |
| //operator*(const quantity<Unit,X>& lhs,const Y& rhs) |
| //{ |
| // typedef typename multiply_typeof_helper< quantity<Unit,X>,Y >::type type; |
| // |
| // return type::from_value(lhs.value()*rhs); |
| //} |
| // |
| ///// runtime scalar times quantity |
| //template<class Unit, |
| // class X, |
| // class Y> |
| //inline |
| //typename multiply_typeof_helper< X,quantity<Unit,Y> >::type |
| //operator*(const X& lhs,const quantity<Unit,Y>& rhs) |
| //{ |
| // typedef typename multiply_typeof_helper< X,quantity<Unit,Y> >::type type; |
| // |
| // return type::from_value(lhs*rhs.value()); |
| //} |
| |
| /// runtime quantity times scalar |
| template<class Unit, |
| class X> |
| inline |
| typename multiply_typeof_helper< quantity<Unit,X>,X >::type |
| operator*(const quantity<Unit,X>& lhs,const X& rhs) |
| { |
| typedef typename multiply_typeof_helper< quantity<Unit,X>,X >::type type; |
| |
| return type::from_value(lhs.value()*rhs); |
| } |
| |
| /// runtime scalar times quantity |
| template<class Unit, |
| class X> |
| inline |
| typename multiply_typeof_helper< X,quantity<Unit,X> >::type |
| operator*(const X& lhs,const quantity<Unit,X>& rhs) |
| { |
| typedef typename multiply_typeof_helper< X,quantity<Unit,X> >::type type; |
| |
| return type::from_value(lhs*rhs.value()); |
| } |
| |
| ///// runtime quantity divided by scalar |
| //template<class Unit, |
| // class X, |
| // class Y> |
| //inline |
| //typename divide_typeof_helper< quantity<Unit,X>,Y >::type |
| //operator/(const quantity<Unit,X>& lhs,const Y& rhs) |
| //{ |
| // typedef typename divide_typeof_helper< quantity<Unit,X>,Y >::type type; |
| // |
| // return type::from_value(lhs.value()/rhs); |
| //} |
| // |
| ///// runtime scalar divided by quantity |
| //template<class Unit, |
| // class X, |
| // class Y> |
| //inline |
| //typename divide_typeof_helper< X,quantity<Unit,Y> >::type |
| //operator/(const X& lhs,const quantity<Unit,Y>& rhs) |
| //{ |
| // typedef typename divide_typeof_helper< X,quantity<Unit,Y> >::type type; |
| // |
| // return type::from_value(lhs/rhs.value()); |
| //} |
| |
| /// runtime quantity divided by scalar |
| template<class Unit, |
| class X> |
| inline |
| typename divide_typeof_helper< quantity<Unit,X>,X >::type |
| operator/(const quantity<Unit,X>& lhs,const X& rhs) |
| { |
| typedef typename divide_typeof_helper< quantity<Unit,X>,X >::type type; |
| |
| return type::from_value(lhs.value()/rhs); |
| } |
| |
| /// runtime scalar divided by quantity |
| template<class Unit, |
| class X> |
| inline |
| typename divide_typeof_helper< X,quantity<Unit,X> >::type |
| operator/(const X& lhs,const quantity<Unit,X>& rhs) |
| { |
| typedef typename divide_typeof_helper< X,quantity<Unit,X> >::type type; |
| |
| return type::from_value(lhs/rhs.value()); |
| } |
| |
| /// runtime unit times quantity |
| template<class System1, |
| class Dim1, |
| class Unit2, |
| class Y> |
| inline |
| typename multiply_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type |
| operator*(const unit<Dim1,System1>&,const quantity<Unit2,Y>& rhs) |
| { |
| typedef typename multiply_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type type; |
| |
| return type::from_value(rhs.value()); |
| } |
| |
| /// runtime unit divided by quantity |
| template<class System1, |
| class Dim1, |
| class Unit2, |
| class Y> |
| inline |
| typename divide_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type |
| operator/(const unit<Dim1,System1>&,const quantity<Unit2,Y>& rhs) |
| { |
| typedef typename divide_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type type; |
| |
| return type::from_value(Y(1)/rhs.value()); |
| } |
| |
| /// runtime quantity times unit |
| template<class Unit1, |
| class System2, |
| class Dim2, |
| class Y> |
| inline |
| typename multiply_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type |
| operator*(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&) |
| { |
| typedef typename multiply_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type type; |
| |
| return type::from_value(lhs.value()); |
| } |
| |
| /// runtime quantity divided by unit |
| template<class Unit1, |
| class System2, |
| class Dim2, |
| class Y> |
| inline |
| typename divide_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type |
| operator/(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&) |
| { |
| typedef typename divide_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type type; |
| |
| return type::from_value(lhs.value()); |
| } |
| |
| /// runtime unary plus quantity |
| template<class Unit,class Y> |
| typename unary_plus_typeof_helper< quantity<Unit,Y> >::type |
| operator+(const quantity<Unit,Y>& val) |
| { |
| typedef typename unary_plus_typeof_helper< quantity<Unit,Y> >::type type; |
| |
| return type::from_value(+val.value()); |
| } |
| |
| /// runtime unary minus quantity |
| template<class Unit,class Y> |
| typename unary_minus_typeof_helper< quantity<Unit,Y> >::type |
| operator-(const quantity<Unit,Y>& val) |
| { |
| typedef typename unary_minus_typeof_helper< quantity<Unit,Y> >::type type; |
| |
| return type::from_value(-val.value()); |
| } |
| |
| /// runtime quantity plus quantity |
| template<class Unit1, |
| class Unit2, |
| class X, |
| class Y> |
| inline |
| typename add_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type |
| operator+(const quantity<Unit1,X>& lhs, |
| const quantity<Unit2,Y>& rhs) |
| { |
| typedef typename add_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type type; |
| |
| return type::from_value(lhs.value()+rhs.value()); |
| } |
| |
| /// runtime quantity minus quantity |
| template<class Unit1, |
| class Unit2, |
| class X, |
| class Y> |
| inline |
| typename subtract_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type |
| operator-(const quantity<Unit1,X>& lhs, |
| const quantity<Unit2,Y>& rhs) |
| { |
| typedef typename subtract_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type type; |
| |
| return type::from_value(lhs.value()-rhs.value()); |
| } |
| |
| /// runtime quantity times quantity |
| template<class Unit1, |
| class Unit2, |
| class X, |
| class Y> |
| inline |
| typename multiply_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type |
| operator*(const quantity<Unit1,X>& lhs, |
| const quantity<Unit2,Y>& rhs) |
| { |
| typedef typename multiply_typeof_helper< quantity<Unit1,X>, |
| quantity<Unit2,Y> >::type type; |
| |
| return type::from_value(lhs.value()*rhs.value()); |
| } |
| |
| /// runtime quantity divided by quantity |
| template<class Unit1, |
| class Unit2, |
| class X, |
| class Y> |
| inline |
| typename divide_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type |
| operator/(const quantity<Unit1,X>& lhs, |
| const quantity<Unit2,Y>& rhs) |
| { |
| typedef typename divide_typeof_helper< quantity<Unit1,X>, |
| quantity<Unit2,Y> >::type type; |
| |
| return type::from_value(lhs.value()/rhs.value()); |
| } |
| |
| /// runtime operator== |
| template<class Unit, |
| class X, |
| class Y> |
| inline |
| bool |
| operator==(const quantity<Unit,X>& val1, |
| const quantity<Unit,Y>& val2) |
| { |
| return val1.value() == val2.value(); |
| } |
| |
| /// runtime operator!= |
| template<class Unit, |
| class X, |
| class Y> |
| inline |
| bool |
| operator!=(const quantity<Unit,X>& val1, |
| const quantity<Unit,Y>& val2) |
| { |
| return val1.value() != val2.value(); |
| } |
| |
| /// runtime operator< |
| template<class Unit, |
| class X, |
| class Y> |
| inline |
| bool |
| operator<(const quantity<Unit,X>& val1, |
| const quantity<Unit,Y>& val2) |
| { |
| return val1.value() < val2.value(); |
| } |
| |
| /// runtime operator<= |
| template<class Unit, |
| class X, |
| class Y> |
| inline |
| bool |
| operator<=(const quantity<Unit,X>& val1, |
| const quantity<Unit,Y>& val2) |
| { |
| return val1.value() <= val2.value(); |
| } |
| |
| /// runtime operator> |
| template<class Unit, |
| class X, |
| class Y> |
| inline |
| bool |
| operator>(const quantity<Unit,X>& val1, |
| const quantity<Unit,Y>& val2) |
| { |
| return val1.value() > val2.value(); |
| } |
| |
| /// runtime operator>= |
| template<class Unit, |
| class X, |
| class Y> |
| inline |
| bool |
| operator>=(const quantity<Unit,X>& val1, |
| const quantity<Unit,Y>& val2) |
| { |
| return val1.value() >= val2.value(); |
| } |
| |
| } // namespace units |
| |
| } // namespace boost |
| |
| #endif // BOOST_UNITS_QUANTITY_HPP |