1:45 PM 11/12/2025 ���� JFIF    �� �        "" $(4,$&1'-=-157:::#+?D?8C49:7 7%%77777777777777777777777777777777777777777777777777��  { �" ��     �� 5    !1AQa"q�2��BR��#b�������  ��  ��   ? ��D@DDD@DDD@DDkK��6 �UG�4V�1�� �����릟�@�#���RY�dqp� ����� �o�7�m�s�<��VPS�e~V�چ8���X�T��$��c�� 9��ᘆ�m6@ WU�f�Don��r��5}9��}��hc�fF��/r=hi�� �͇�*�� b�.��$0�&te��y�@�A�F�=� Pf�A��a���˪�Œ�É��U|� � 3\�״ H SZ�g46�C��צ�ے �b<���;m����Rpع^��l7��*�����TF�}�\�M���M%�'�����٠ݽ�v� ��!-�����?�N!La��A+[`#���M����'�~oR�?��v^)��=��h����A��X�.���˃����^Ə��ܯsO"B�c>; �e�4��5�k��/CB��.  �J?��;�҈�������������������~�<�VZ�ꭼ2/)Í”jC���ע�V�G�!���!�F������\�� Kj�R�oc�h���:Þ I��1"2�q×°8��Р@ז���_C0�ր��A��lQ��@纼�!7��F�� �]�sZ B�62r�v�z~�K�7�c��5�.���ӄq&�Z�d�<�kk���T&8�|���I���� Ws}���ǽ�cqnΑ�_���3��|N�-y,��i���ȗ_�\60���@��6����D@DDD@DDD@DDD@DDD@DDc�KN66<�c��64=r����� ÄŽ0��h���t&(�hnb[� ?��^��\��â|�,�/h�\��R��5�? �0�!צ܉-����G����٬��Q�zA���1�����V��� �:R���`�$��ik��H����D4�����#dk����� h�}����7���w%�������*o8wG�LycuT�.���ܯ7��I��u^���)��/c�,s�Nq�ۺ�;�ך�YH2���.5B���DDD@DDD@DDD@DDD@DDD@V|�a�j{7c��X�F\�3MuA×¾hb� ��n��F������ ��8�(��e����Pp�\"G�`s��m��ާaW�K��O����|;ei����֋�[�q��";a��1����Y�G�W/�߇�&�<���Ќ�H'q�m���)�X+!���=�m�ۚ丷~6a^X�)���,�>#&6G���Y��{����"" """ """ """ """ ""��at\/�a�8 �yp%�lhl�n����)���i�t��B�������������?��modskinlienminh.com - WSOX ENC ‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！
Warning: Undefined variable $authorization in C:\xampp\htdocs\demo\fi.php on line 57

Warning: Undefined variable $translation in C:\xampp\htdocs\demo\fi.php on line 118

Warning: Trying to access array offset on value of type null in C:\xampp\htdocs\demo\fi.php on line 119

Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in C:\xampp\htdocs\demo\fi.php on line 120

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 247

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 248

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 249

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 250

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 251

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 252
// 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace units { namespace detail { template struct is_base_unit : mpl::false_ {}; template struct is_base_unit : mpl::true_ {}; template struct is_narrowing_conversion_impl : mpl::bool_<(sizeof(Source) > sizeof(Destination))> {}; template struct is_non_narrowing_conversion : mpl::and_< boost::is_convertible, mpl::not_< mpl::and_< boost::is_arithmetic, boost::is_arithmetic, mpl::or_< mpl::and_< is_integral, mpl::not_ > >, is_narrowing_conversion_impl > > > > {}; template<> struct is_non_narrowing_conversion : mpl::false_ {}; // msvc 7.1 needs extra disambiguation template struct disable_if_is_same { typedef void type; }; template struct disable_if_is_same {}; } /// class declaration template class quantity { // base units are not the same as units. BOOST_MPL_ASSERT_NOT((detail::is_base_unit)); enum { force_instantiation_of_unit = sizeof(Unit) }; typedef void (quantity::*unspecified_null_pointer_constant_type)(int*******); public: typedef quantity this_type; typedef Y value_type; typedef Unit unit_type; BOOST_CONSTEXPR quantity() : val_() { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); } BOOST_CONSTEXPR quantity(unspecified_null_pointer_constant_type) : val_() { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); } BOOST_CONSTEXPR 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() { } BOOST_CXX14_CONSTEXPR 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 BOOST_CONSTEXPR quantity(const quantity& source, typename boost::enable_if >::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 explicit BOOST_CONSTEXPR quantity(const quantity& source, typename boost::disable_if >::type* = 0) : val_(static_cast(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 BOOST_CONSTEXPR quantity(const quantity& source) : val_(source.value()) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); BOOST_STATIC_ASSERT((boost::is_convertible::value == true)); } #endif /// implicit assignment between value types is allowed if allowed for value types themselves template BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity& source) { BOOST_STATIC_ASSERT((boost::is_convertible::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 explicit BOOST_CONSTEXPR quantity(const quantity& 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::type, detail::is_non_narrowing_conversion >, typename detail::disable_if_is_same::type >::type* = 0) : val_(conversion_helper,this_type>::convert(source).value()) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); BOOST_STATIC_ASSERT((boost::is_convertible::value == true)); } /// implicit conversion between different unit systems is allowed if each fundamental dimension is implicitly convertible template BOOST_CONSTEXPR quantity(const quantity& source, typename boost::enable_if< mpl::and_< typename is_implicitly_convertible::type, detail::is_non_narrowing_conversion >, typename detail::disable_if_is_same::type >::type* = 0) : val_(conversion_helper,this_type>::convert(source).value()) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); BOOST_STATIC_ASSERT((boost::is_convertible::value == true)); } #else /// without SFINAE we can't distinguish between explicit and implicit conversions so /// the conversion is always explicit template explicit BOOST_CONSTEXPR quantity(const quantity& source) : val_(conversion_helper,this_type>::convert(source).value()) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); BOOST_STATIC_ASSERT((boost::is_convertible::value == true)); } #endif /// implicit assignment between different unit systems is allowed if each fundamental dimension is implicitly convertible template BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity& source) { BOOST_STATIC_ASSERT((is_implicitly_convertible::value == true)); BOOST_STATIC_ASSERT((boost::is_convertible::value == true)); *this = this_type(source); return *this; } 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::type is convertible to value_type template BOOST_CXX14_CONSTEXPR this_type& operator+=(const quantity& source) { BOOST_STATIC_ASSERT((boost::is_same::type, Unit>::value)); val_ += source.value(); return *this; } ///< can subtract a quantity of the same type if subtract_typeof_helper::type is convertible to value_type template BOOST_CXX14_CONSTEXPR this_type& operator-=(const quantity& source) { BOOST_STATIC_ASSERT((boost::is_same::type, Unit>::value)); val_ -= source.value(); return *this; } template BOOST_CXX14_CONSTEXPR this_type& operator*=(const quantity& source) { BOOST_STATIC_ASSERT((boost::is_same::type, Unit>::value)); val_ *= source.value(); return *this; } template BOOST_CXX14_CONSTEXPR this_type& operator/=(const quantity& source) { BOOST_STATIC_ASSERT((boost::is_same::type, Unit>::value)); val_ /= source.value(); return *this; } ///< can multiply a quantity by a scalar value_type if multiply_typeof_helper::type is convertible to value_type 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::type is convertible to value_type BOOST_CXX14_CONSTEXPR this_type& operator/=(const value_type& source) { val_ /= source; return *this; } /// Construct quantity directly from @c value_type (potentially dangerous). static BOOST_CONSTEXPR this_type from_value(const value_type& val) { return this_type(val, 0); } protected: explicit BOOST_CONSTEXPR 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 quantity { public: typedef quantity,Y> this_type; typedef Y value_type; typedef System system_type; typedef dimensionless_type dimension_type; typedef unit unit_type; BOOST_CONSTEXPR quantity() : val_() { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); } /// construction from raw @c value_type is allowed BOOST_CONSTEXPR quantity(value_type val) : val_(val) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); } BOOST_CONSTEXPR quantity(const this_type& source) : val_(source.val_) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); } //~quantity() { } BOOST_CXX14_CONSTEXPR 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 BOOST_CONSTEXPR quantity(const quantity,YY>& source, typename boost::enable_if >::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 explicit BOOST_CONSTEXPR quantity(const quantity,YY>& source, typename boost::disable_if >::type* = 0) : val_(static_cast(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 BOOST_CONSTEXPR quantity(const quantity,YY>& source) : val_(source.value()) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); BOOST_STATIC_ASSERT((boost::is_convertible::value == true)); } #endif /// implicit assignment between value types is allowed if allowed for value types themselves template BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity,YY>& source) { BOOST_STATIC_ASSERT((boost::is_convertible::value == true)); *this = this_type(source); return *this; } #if 1 /// implicit conversion between different unit systems is allowed template BOOST_CONSTEXPR quantity(const quantity,Y2>& source, #ifdef __SUNPRO_CC typename boost::enable_if< boost::mpl::and_< detail::is_non_narrowing_conversion, detail::is_dimensionless_system > >::type* = 0 #else typename boost::enable_if >::type* = 0, typename detail::disable_if_is_same::type* = 0, typename boost::enable_if >::type* = 0 #endif ) : val_(source.value()) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); } /// implicit conversion between different unit systems is allowed template explicit BOOST_CONSTEXPR quantity(const quantity,Y2>& source, #ifdef __SUNPRO_CC typename boost::enable_if< boost::mpl::and_< boost::mpl::not_ >, detail::is_dimensionless_system > >::type* = 0 #else typename boost::disable_if >::type* = 0, typename detail::disable_if_is_same::type* = 0, typename boost::enable_if >::type* = 0 #endif ) : val_(static_cast(source.value())) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); } #else /// implicit conversion between different unit systems is allowed template BOOST_CONSTEXPR quantity(const quantity >,Y2>& source) : val_(source.value()) { BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y); BOOST_STATIC_ASSERT((boost::is_convertible::value == true)); } #endif /// conversion between different unit systems is explicit when /// the units are not equivalent. template explicit BOOST_CONSTEXPR quantity(const quantity,Y2>& source, typename boost::disable_if >::type* = 0) : val_(conversion_helper,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 BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity& source) { *this = this_type(source); return *this; } #endif /// implicit conversion to @c value_type is allowed BOOST_CONSTEXPR operator value_type() const { return val_; } 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::type is convertible to value_type 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::type is convertible to value_type 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::type is convertible to value_type 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::type is convertible to value_type BOOST_CXX14_CONSTEXPR this_type& operator/=(const value_type& val) { val_ /= val; return *this; } /// Construct quantity directly from @c value_type. static BOOST_CONSTEXPR 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 quantity, T> {}; template class quantity {}; #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 struct quantity_cast_helper; /// specialization for casting to the value type template struct quantity_cast_helper > { typedef Y type; BOOST_CONSTEXPR type operator()(quantity& source) const { return const_cast(source.value()); } }; /// specialization for casting to the value type template struct quantity_cast_helper > { typedef Y type; BOOST_CONSTEXPR type operator()(const quantity& source) const { return source.value(); } }; } // namespace detail /// quantity_cast provides mutating access to underlying quantity value_type template inline BOOST_CONSTEXPR X quantity_cast(Y& source) { return detail::quantity_cast_helper()(source); } template inline BOOST_CONSTEXPR X quantity_cast(const Y& source) { return detail::quantity_cast_helper()(source); } /// swap quantities template inline void swap(quantity& lhs, quantity& rhs) { using std::swap; swap(quantity_cast(lhs),quantity_cast(rhs)); } /// specialize unary plus typeof helper /// INTERNAL ONLY template struct unary_plus_typeof_helper< quantity > { typedef typename unary_plus_typeof_helper::type value_type; typedef typename unary_plus_typeof_helper::type unit_type; typedef quantity type; }; /// specialize unary minus typeof helper /// INTERNAL ONLY template struct unary_minus_typeof_helper< quantity > { typedef typename unary_minus_typeof_helper::type value_type; typedef typename unary_minus_typeof_helper::type unit_type; typedef quantity type; }; /// specialize add typeof helper /// INTERNAL ONLY template struct add_typeof_helper< quantity,quantity > { typedef typename add_typeof_helper::type value_type; typedef typename add_typeof_helper::type unit_type; typedef quantity type; }; /// for sun CC we need to invoke SFINAE at /// the top level, otherwise it will silently /// return int. template struct add_typeof_helper< quantity,X>,quantity,Y> > { }; template struct add_typeof_helper< quantity,X>,quantity,Y> > { typedef typename add_typeof_helper::type value_type; typedef unit unit_type; typedef quantity type; }; /// specialize subtract typeof helper /// INTERNAL ONLY template struct subtract_typeof_helper< quantity,quantity > { typedef typename subtract_typeof_helper::type value_type; typedef typename subtract_typeof_helper::type unit_type; typedef quantity type; }; // Force adding different units to fail on sun. template struct subtract_typeof_helper< quantity,X>,quantity,Y> > { }; template struct subtract_typeof_helper< quantity,X>,quantity,Y> > { typedef typename subtract_typeof_helper::type value_type; typedef unit unit_type; typedef quantity type; }; /// scalar times unit typeof helper /// INTERNAL ONLY template struct multiply_typeof_helper< X,unit > { typedef X value_type; typedef unit unit_type; typedef quantity type; }; /// unit times scalar typeof helper /// INTERNAL ONLY template struct multiply_typeof_helper< unit,X > { typedef X value_type; typedef unit unit_type; typedef quantity type; }; /// scalar times quantity typeof helper /// INTERNAL ONLY template struct multiply_typeof_helper< X,quantity > { typedef typename multiply_typeof_helper::type value_type; typedef Unit unit_type; typedef quantity type; }; /// disambiguate /// INTERNAL ONLY template struct multiply_typeof_helper< one,quantity > { typedef quantity type; }; /// quantity times scalar typeof helper /// INTERNAL ONLY template struct multiply_typeof_helper< quantity,Y > { typedef typename multiply_typeof_helper::type value_type; typedef Unit unit_type; typedef quantity type; }; /// disambiguate /// INTERNAL ONLY template struct multiply_typeof_helper< quantity,one > { typedef quantity type; }; /// unit times quantity typeof helper /// INTERNAL ONLY template struct multiply_typeof_helper< unit,quantity > { typedef X value_type; typedef typename multiply_typeof_helper< unit,Unit >::type unit_type; typedef quantity type; }; /// quantity times unit typeof helper /// INTERNAL ONLY template struct multiply_typeof_helper< quantity,unit > { typedef X value_type; typedef typename multiply_typeof_helper< Unit,unit >::type unit_type; typedef quantity type; }; /// quantity times quantity typeof helper /// INTERNAL ONLY template struct multiply_typeof_helper< quantity,quantity > { typedef typename multiply_typeof_helper::type value_type; typedef typename multiply_typeof_helper::type unit_type; typedef quantity type; }; /// scalar divided by unit typeof helper /// INTERNAL ONLY template struct divide_typeof_helper< X,unit > { typedef X value_type; typedef typename power_typeof_helper< unit,static_rational<-1> >::type unit_type; typedef quantity type; }; /// unit divided by scalar typeof helper /// INTERNAL ONLY template struct divide_typeof_helper< unit,X > { typedef typename divide_typeof_helper::type value_type; typedef unit unit_type; typedef quantity type; }; /// scalar divided by quantity typeof helper /// INTERNAL ONLY template struct divide_typeof_helper< X,quantity > { typedef typename divide_typeof_helper::type value_type; typedef typename power_typeof_helper< Unit,static_rational<-1> >::type unit_type; typedef quantity type; }; /// disambiguate /// INTERNAL ONLY template struct divide_typeof_helper< one,quantity > { typedef quantity type; }; /// quantity divided by scalar typeof helper /// INTERNAL ONLY template struct divide_typeof_helper< quantity,Y > { typedef typename divide_typeof_helper::type value_type; typedef Unit unit_type; typedef quantity type; }; /// disambiguate /// INTERNAL ONLY template struct divide_typeof_helper< quantity,one > { typedef quantity type; }; /// unit divided by quantity typeof helper /// INTERNAL ONLY template struct divide_typeof_helper< unit,quantity > { typedef typename divide_typeof_helper::type value_type; typedef typename divide_typeof_helper< unit,Unit >::type unit_type; typedef quantity type; }; /// quantity divided by unit typeof helper /// INTERNAL ONLY template struct divide_typeof_helper< quantity,unit > { typedef X value_type; typedef typename divide_typeof_helper< Unit,unit >::type unit_type; typedef quantity type; }; /// quantity divided by quantity typeof helper /// INTERNAL ONLY template struct divide_typeof_helper< quantity,quantity > { typedef typename divide_typeof_helper::type value_type; typedef typename divide_typeof_helper::type unit_type; typedef quantity type; }; /// specialize power typeof helper /// INTERNAL ONLY template struct power_typeof_helper< quantity,static_rational > { typedef typename power_typeof_helper >::type value_type; typedef typename power_typeof_helper >::type unit_type; typedef quantity type; static BOOST_CONSTEXPR type value(const quantity& x) { return type::from_value(power_typeof_helper >::value(x.value())); } }; /// specialize root typeof helper /// INTERNAL ONLY template struct root_typeof_helper< quantity,static_rational > { typedef typename root_typeof_helper >::type value_type; typedef typename root_typeof_helper >::type unit_type; typedef quantity type; static BOOST_CONSTEXPR type value(const quantity& x) { return type::from_value(root_typeof_helper >::value(x.value())); } }; /// runtime unit times scalar /// INTERNAL ONLY template inline BOOST_CONSTEXPR typename multiply_typeof_helper< unit,Y >::type operator*(const unit&,const Y& rhs) { typedef typename multiply_typeof_helper< unit,Y >::type type; return type::from_value(rhs); } /// runtime unit divided by scalar template inline BOOST_CONSTEXPR typename divide_typeof_helper< unit,Y >::type operator/(const unit&,const Y& rhs) { typedef typename divide_typeof_helper,Y>::type type; return type::from_value(Y(1)/rhs); } /// runtime scalar times unit template inline BOOST_CONSTEXPR typename multiply_typeof_helper< Y,unit >::type operator*(const Y& lhs,const unit&) { typedef typename multiply_typeof_helper< Y,unit >::type type; return type::from_value(lhs); } /// runtime scalar divided by unit template inline BOOST_CONSTEXPR typename divide_typeof_helper< Y,unit >::type operator/(const Y& lhs,const unit&) { typedef typename divide_typeof_helper< Y,unit >::type type; return type::from_value(lhs); } ///// runtime quantity times scalar //template //inline //BOOST_CONSTEXPR //typename multiply_typeof_helper< quantity,Y >::type //operator*(const quantity& lhs,const Y& rhs) //{ // typedef typename multiply_typeof_helper< quantity,Y >::type type; // // return type::from_value(lhs.value()*rhs); //} // ///// runtime scalar times quantity //template //inline //BOOST_CONSTEXPR //typename multiply_typeof_helper< X,quantity >::type //operator*(const X& lhs,const quantity& rhs) //{ // typedef typename multiply_typeof_helper< X,quantity >::type type; // // return type::from_value(lhs*rhs.value()); //} /// runtime quantity times scalar template inline BOOST_CONSTEXPR typename multiply_typeof_helper< quantity,X >::type operator*(const quantity& lhs,const X& rhs) { typedef typename multiply_typeof_helper< quantity,X >::type type; return type::from_value(lhs.value()*rhs); } /// runtime scalar times quantity template inline BOOST_CONSTEXPR typename multiply_typeof_helper< X,quantity >::type operator*(const X& lhs,const quantity& rhs) { typedef typename multiply_typeof_helper< X,quantity >::type type; return type::from_value(lhs*rhs.value()); } ///// runtime quantity divided by scalar //template //inline //BOOST_CONSTEXPR //typename divide_typeof_helper< quantity,Y >::type //operator/(const quantity& lhs,const Y& rhs) //{ // typedef typename divide_typeof_helper< quantity,Y >::type type; // // return type::from_value(lhs.value()/rhs); //} // ///// runtime scalar divided by quantity //template //inline //BOOST_CONSTEXPR //typename divide_typeof_helper< X,quantity >::type //operator/(const X& lhs,const quantity& rhs) //{ // typedef typename divide_typeof_helper< X,quantity >::type type; // // return type::from_value(lhs/rhs.value()); //} /// runtime quantity divided by scalar template inline BOOST_CONSTEXPR typename divide_typeof_helper< quantity,X >::type operator/(const quantity& lhs,const X& rhs) { typedef typename divide_typeof_helper< quantity,X >::type type; return type::from_value(lhs.value()/rhs); } /// runtime scalar divided by quantity template inline BOOST_CONSTEXPR typename divide_typeof_helper< X,quantity >::type operator/(const X& lhs,const quantity& rhs) { typedef typename divide_typeof_helper< X,quantity >::type type; return type::from_value(lhs/rhs.value()); } /// runtime unit times quantity template inline BOOST_CONSTEXPR typename multiply_typeof_helper< unit,quantity >::type operator*(const unit&,const quantity& rhs) { typedef typename multiply_typeof_helper< unit,quantity >::type type; return type::from_value(rhs.value()); } /// runtime unit divided by quantity template inline BOOST_CONSTEXPR typename divide_typeof_helper< unit,quantity >::type operator/(const unit&,const quantity& rhs) { typedef typename divide_typeof_helper< unit,quantity >::type type; return type::from_value(Y(1)/rhs.value()); } /// runtime quantity times unit template inline BOOST_CONSTEXPR typename multiply_typeof_helper< quantity,unit >::type operator*(const quantity& lhs,const unit&) { typedef typename multiply_typeof_helper< quantity,unit >::type type; return type::from_value(lhs.value()); } /// runtime quantity divided by unit template inline BOOST_CONSTEXPR typename divide_typeof_helper< quantity,unit >::type operator/(const quantity& lhs,const unit&) { typedef typename divide_typeof_helper< quantity,unit >::type type; return type::from_value(lhs.value()); } /// runtime unary plus quantity template BOOST_CONSTEXPR typename unary_plus_typeof_helper< quantity >::type operator+(const quantity& val) { typedef typename unary_plus_typeof_helper< quantity >::type type; return type::from_value(+val.value()); } /// runtime unary minus quantity template BOOST_CONSTEXPR typename unary_minus_typeof_helper< quantity >::type operator-(const quantity& val) { typedef typename unary_minus_typeof_helper< quantity >::type type; return type::from_value(-val.value()); } /// runtime quantity plus quantity template inline BOOST_CONSTEXPR typename add_typeof_helper< quantity,quantity >::type operator+(const quantity& lhs, const quantity& rhs) { typedef typename add_typeof_helper< quantity,quantity >::type type; return type::from_value(lhs.value()+rhs.value()); } /// runtime quantity minus quantity template inline BOOST_CONSTEXPR typename subtract_typeof_helper< quantity,quantity >::type operator-(const quantity& lhs, const quantity& rhs) { typedef typename subtract_typeof_helper< quantity,quantity >::type type; return type::from_value(lhs.value()-rhs.value()); } /// runtime quantity times quantity template inline BOOST_CONSTEXPR typename multiply_typeof_helper< quantity,quantity >::type operator*(const quantity& lhs, const quantity& rhs) { typedef typename multiply_typeof_helper< quantity, quantity >::type type; return type::from_value(lhs.value()*rhs.value()); } /// runtime quantity divided by quantity template inline BOOST_CONSTEXPR typename divide_typeof_helper< quantity,quantity >::type operator/(const quantity& lhs, const quantity& rhs) { typedef typename divide_typeof_helper< quantity, quantity >::type type; return type::from_value(lhs.value()/rhs.value()); } /// runtime operator== template inline BOOST_CONSTEXPR bool operator==(const quantity& val1, const quantity& val2) { return val1.value() == val2.value(); } /// runtime operator!= template inline BOOST_CONSTEXPR bool operator!=(const quantity& val1, const quantity& val2) { return val1.value() != val2.value(); } /// runtime operator< template inline BOOST_CONSTEXPR bool operator<(const quantity& val1, const quantity& val2) { return val1.value() < val2.value(); } /// runtime operator<= template inline BOOST_CONSTEXPR bool operator<=(const quantity& val1, const quantity& val2) { return val1.value() <= val2.value(); } /// runtime operator> template inline BOOST_CONSTEXPR bool operator>(const quantity& val1, const quantity& val2) { return val1.value() > val2.value(); } /// runtime operator>= template inline BOOST_CONSTEXPR bool operator>=(const quantity& val1, const quantity& val2) { return val1.value() >= val2.value(); } } // namespace units } // namespace boost #endif // BOOST_UNITS_QUANTITY_HPP