diff options
Diffstat (limited to 'boost/units/absolute.hpp')
-rw-r--r-- | boost/units/absolute.hpp | 153 |
1 files changed, 153 insertions, 0 deletions
diff --git a/boost/units/absolute.hpp b/boost/units/absolute.hpp new file mode 100644 index 0000000000..c035475a40 --- /dev/null +++ b/boost/units/absolute.hpp @@ -0,0 +1,153 @@ +// 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) 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) + +/// +/// \file +/// \brief Absolute units (points rather than vectors). +/// \details Operations between absolute units, and relative units like temperature differences. +/// + +#ifndef BOOST_UNITS_ABSOLUTE_HPP +#define BOOST_UNITS_ABSOLUTE_HPP + +#include <iosfwd> + +#include <boost/units/detail/absolute_impl.hpp> + +namespace boost { + +namespace units { + +/// A wrapper to represent absolute units (points rather than vectors). Intended +/// originally for temperatures, this class implements operators for absolute units +/// so that addition of a relative unit to an absolute unit results in another +/// absolute unit : absolute<T> +/- T -> absolute<T> and subtraction of one absolute +/// unit from another results in a relative unit : absolute<T> - absolute<T> -> T. +template<class Y> +class absolute +{ + public: + typedef absolute<Y> this_type; + typedef Y value_type; + + absolute() : val_() { } + absolute(const value_type& val) : val_(val) { } + absolute(const this_type& source) : val_(source.val_) { } + + this_type& operator=(const this_type& source) { val_ = source.val_; return *this; } + + const value_type& value() const { return val_; } + + const this_type& operator+=(const value_type& val) { val_ += val; return *this; } + const this_type& operator-=(const value_type& val) { val_ -= val; return *this; } + + private: + value_type val_; +}; + +/// add a relative value to an absolute one +template<class Y> +absolute<Y> operator+(const absolute<Y>& aval,const Y& rval) +{ + return absolute<Y>(aval.value()+rval); +} + +/// add a relative value to an absolute one +template<class Y> +absolute<Y> operator+(const Y& rval,const absolute<Y>& aval) +{ + return absolute<Y>(aval.value()+rval); +} + +/// subtract a relative value from an absolute one +template<class Y> +absolute<Y> operator-(const absolute<Y>& aval,const Y& rval) +{ + return absolute<Y>(aval.value()-rval); +} + +/// subtracting two absolutes gives a difference +template<class Y> +Y operator-(const absolute<Y>& aval1,const absolute<Y>& aval2) +{ + return Y(aval1.value()-aval2.value()); +} + +/// creates a quantity from an absolute unit and a raw value +template<class D, class S, class T> +quantity<absolute<unit<D, S> >, T> operator*(const T& t, const absolute<unit<D, S> >&) +{ + return(quantity<absolute<unit<D, S> >, T>::from_value(t)); +} + +/// creates a quantity from an absolute unit and a raw value +template<class D, class S, class T> +quantity<absolute<unit<D, S> >, T> operator*(const absolute<unit<D, S> >&, const T& t) +{ + return(quantity<absolute<unit<D, S> >, T>::from_value(t)); +} + +/// Print an absolute unit +template<class Char, class Traits, class Y> +std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,const absolute<Y>& aval) +{ + + os << "absolute " << aval.value(); + + return os; +} + +} // namespace units + +} // namespace boost + +#if BOOST_UNITS_HAS_BOOST_TYPEOF + +#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() + +BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::absolute, (class)) + +#endif + +namespace boost { + +namespace units { + +/// Macro to define the offset between two absolute units. +/// Requires the value to be in the destination units e.g +/// @code +/// BOOST_UNITS_DEFINE_CONVERSION_OFFSET(celsius_base_unit, fahrenheit_base_unit, double, 32.0); +/// @endcode +/// @c BOOST_UNITS_DEFINE_CONVERSION_FACTOR is also necessary to +/// specify the conversion factor. Like @c BOOST_UNITS_DEFINE_CONVERSION_FACTOR +/// this macro defines both forward and reverse conversions so +/// defining, e.g., the conversion from celsius to fahrenheit as above will also +/// define the inverse conversion from fahrenheit to celsius. +#define BOOST_UNITS_DEFINE_CONVERSION_OFFSET(From, To, type_, value_) \ + namespace boost { \ + namespace units { \ + template<> \ + struct affine_conversion_helper< \ + reduce_unit<From::unit_type>::type, \ + reduce_unit<To::unit_type>::type> \ + { \ + static const bool is_defined = true; \ + typedef type_ type; \ + static type value() { return(value_); } \ + }; \ + } \ + } \ + void boost_units_require_semicolon() + +} // namespace units + +} // namespace boost + +#endif // BOOST_UNITS_ABSOLUTE_HPP |