summaryrefslogtreecommitdiff
path: root/boost/units/absolute.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/units/absolute.hpp')
-rw-r--r--boost/units/absolute.hpp153
1 files changed, 153 insertions, 0 deletions
diff --git a/boost/units/absolute.hpp b/boost/units/absolute.hpp
new file mode 100644
index 0000000..c035475
--- /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