|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r60654 - branches/units/autoprefix/boost/units
From: pbristow_at_[hidden]
Date: 2010-03-16 14:38:56
Author: pbristow
Date: 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
New Revision: 60654
URL: http://svn.boost.org/trac/boost/changeset/60654
Log:
Doxygen file info updated.
Text files modified:
branches/units/autoprefix/boost/units/absolute.hpp | 27 ++-
branches/units/autoprefix/boost/units/base_dimension.hpp | 26 ++-
branches/units/autoprefix/boost/units/base_unit.hpp | 22 +-
branches/units/autoprefix/boost/units/cmath.hpp | 223 +++++++++++++++---------------
branches/units/autoprefix/boost/units/config.hpp | 22 ++
branches/units/autoprefix/boost/units/conversion.hpp | 8
branches/units/autoprefix/boost/units/derived_dimension.hpp | 25 ++-
branches/units/autoprefix/boost/units/dim.hpp | 55 +++---
branches/units/autoprefix/boost/units/dimension.hpp | 48 +++---
branches/units/autoprefix/boost/units/dimensionless_quantity.hpp | 9
branches/units/autoprefix/boost/units/dimensionless_type.hpp | 11
branches/units/autoprefix/boost/units/dimensionless_unit.hpp | 9
branches/units/autoprefix/boost/units/get_dimension.hpp | 14 +
branches/units/autoprefix/boost/units/get_system.hpp | 13 +
branches/units/autoprefix/boost/units/heterogeneous_system.hpp | 11 +
branches/units/autoprefix/boost/units/homogeneous_system.hpp | 17 +
branches/units/autoprefix/boost/units/io.hpp | 98 ++++++------
branches/units/autoprefix/boost/units/is_dim.hpp | 9
branches/units/autoprefix/boost/units/is_dimension_list.hpp | 7
branches/units/autoprefix/boost/units/is_dimensionless.hpp | 13 +
branches/units/autoprefix/boost/units/is_dimensionless_quantity.hpp | 9
branches/units/autoprefix/boost/units/is_dimensionless_unit.hpp | 9
branches/units/autoprefix/boost/units/is_quantity.hpp | 11 +
branches/units/autoprefix/boost/units/is_quantity_of_dimension.hpp | 9
branches/units/autoprefix/boost/units/is_quantity_of_system.hpp | 9
branches/units/autoprefix/boost/units/is_unit.hpp | 11 +
branches/units/autoprefix/boost/units/is_unit_of_dimension.hpp | 9
branches/units/autoprefix/boost/units/is_unit_of_system.hpp | 13 +
branches/units/autoprefix/boost/units/lambda.hpp | 7
branches/units/autoprefix/boost/units/limits.hpp | 8
branches/units/autoprefix/boost/units/make_scaled_unit.hpp | 7
branches/units/autoprefix/boost/units/make_system.hpp | 16 +
branches/units/autoprefix/boost/units/operators.hpp | 36 ++--
branches/units/autoprefix/boost/units/physical_dimensions.hpp | 15 -
branches/units/autoprefix/boost/units/pow.hpp | 24 +-
branches/units/autoprefix/boost/units/quantity.hpp | 293 ++++++++++++++++++++-------------------
branches/units/autoprefix/boost/units/reduce_unit.hpp | 7
branches/units/autoprefix/boost/units/scale.hpp | 13 +
branches/units/autoprefix/boost/units/scaled_base_unit.hpp | 8
branches/units/autoprefix/boost/units/static_constant.hpp | 15 +
branches/units/autoprefix/boost/units/static_rational.hpp | 5
branches/units/autoprefix/boost/units/unit.hpp | 80 +++++-----
branches/units/autoprefix/boost/units/units_fwd.hpp | 14 +
43 files changed, 746 insertions(+), 549 deletions(-)
Modified: branches/units/autoprefix/boost/units/absolute.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/absolute.hpp (original)
+++ branches/units/autoprefix/boost/units/absolute.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -8,9 +8,14 @@
// 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>
@@ -20,28 +25,28 @@
namespace units {
/// A wrapper to represent absolute units (points rather than vectors). Intended
-/// originally for temperatures, this class implements operators for absolute units
+/// 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
+/// 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_;
};
@@ -94,7 +99,7 @@
{
os << "absolute " << aval.value();
-
+
return os;
}
@@ -121,7 +126,7 @@
/// @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
+/// 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_) \
Modified: branches/units/autoprefix/boost/units/base_dimension.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/base_dimension.hpp (original)
+++ branches/units/autoprefix/boost/units/base_dimension.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -8,6 +8,12 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
+///
+/// \file
+/// \brief base dimensions (mass, length, time...).
+/// \details base dimension definition registration.
+///
+
#ifndef BOOST_UNITS_BASE_DIMENSION_HPP
#define BOOST_UNITS_BASE_DIMENSION_HPP
@@ -35,7 +41,7 @@
template<class T, long N>
struct check_base_dimension {
enum {
- value =
+ value =
sizeof(boost_units_is_registered(units::base_dimension_ordinal<N>())) == sizeof(detail::yes) &&
sizeof(boost_units_is_registered(units::base_dimension_pair<T, N>())) != sizeof(detail::yes)
};
@@ -57,14 +63,14 @@
>::type
#endif
>
-class base_dimension :
- public ordinal<N>
+class base_dimension :
+ public ordinal<N>
{
public:
/// INTERNAL ONLY
typedef base_dimension this_type;
/// A convenience typedef. Equivalent to boost::units::derived_dimension<Derived,1>::type.
-#ifndef BOOST_UNITS_DOXYGEN
+#ifndef BOOST_UNITS_DOXYGEN
typedef list<dim<Derived,static_rational<1> >, dimensionless_type> dimension_type;
#else
typedef detail::unspecified dimension_type;
@@ -75,14 +81,14 @@
private:
/// Register this ordinal
/// INTERNAL ONLY
- friend detail::yes
- boost_units_is_registered(const units::base_dimension_ordinal<N>&)
+ friend detail::yes
+ boost_units_is_registered(const units::base_dimension_ordinal<N>&)
{ detail::yes result; return(result); }
-
+
/// But make sure we can identify the current instantiation!
/// INTERNAL ONLY
- friend detail::yes
- boost_units_is_registered(const units::base_dimension_pair<Derived, N>&)
+ friend detail::yes
+ boost_units_is_registered(const units::base_dimension_pair<Derived, N>&)
{ detail::yes result; return(result); }
};
Modified: branches/units/autoprefix/boost/units/base_unit.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/base_unit.hpp (original)
+++ branches/units/autoprefix/boost/units/base_unit.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -8,6 +8,12 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
+///
+/// \file
+/// \brief base unit (meter, kg, sec...).
+/// \details base unit definition registration.
+///
+
#ifndef BOOST_UNITS_BASE_UNIT_HPP
#define BOOST_UNITS_BASE_UNIT_HPP
@@ -60,8 +66,8 @@
>::type
#endif
>
-class base_unit :
- public ordinal<N>
+class base_unit :
+ public ordinal<N>
{
public:
/// INTERNAL ONLY
@@ -96,14 +102,14 @@
private:
/// Register this ordinal
/// INTERNAL ONLY
- friend detail::yes
- boost_units_unit_is_registered(const units::base_unit_ordinal<N>&)
+ friend detail::yes
+ boost_units_unit_is_registered(const units::base_unit_ordinal<N>&)
{ detail::yes result; return(result); }
-
+
/// But make sure we can identify the current instantiation!
/// INTERNAL ONLY
- friend detail::yes
- boost_units_unit_is_registered(const units::base_unit_pair<Derived, N>&)
+ friend detail::yes
+ boost_units_unit_is_registered(const units::base_unit_pair<Derived, N>&)
{ detail::yes result; return(result); }
};
Modified: branches/units/autoprefix/boost/units/cmath.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/cmath.hpp (original)
+++ branches/units/autoprefix/boost/units/cmath.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -8,9 +8,17 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_UNITS_CMATH_HPP
+#ifndef BOOST_UNITS_CMATH_HPP
#define BOOST_UNITS_CMATH_HPP
+///
+/// \file
+/// \brief Overloads of functions in \<cmath\> for quantities.
+/// \details Only functions for which a dimensionally-correct result type
+/// can be determined are overloaded.
+/// All functions work with dimensionless quantities.
+///
+
#include <boost/config/no_tr1/cmath.hpp>
#include <cstdlib>
@@ -27,14 +35,7 @@
#include <boost/units/systems/si/plane_angle.hpp>
-/// \file cmath.hpp
-/// \brief Overloads of functions in \<cmath\> for quantities
-///
-/// \details Only functions for which a dimensionally-correct result type
-/// can be determined are overloaded. All functions work with dimensionless
-/// quantities.
-
-// BOOST_PREVENT_MACRO_SUBSTITUTION is needed on certain compilers that define
+// BOOST_PREVENT_MACRO_SUBSTITUTION is needed on certain compilers that define
// some <cmath> functions as macros; it is used for all functions even though it
// isn't necessary -- I didn't want to think :)
//
@@ -43,186 +44,186 @@
namespace boost {
-namespace units {
+namespace units {
template<class Unit,class Y>
-inline
-bool
+inline
+bool
isfinite BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
-{
+{
using boost::math::isfinite;
return isfinite BOOST_PREVENT_MACRO_SUBSTITUTION (q.value());
}
template<class Unit,class Y>
-inline
-bool
+inline
+bool
isinf BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
-{
+{
using boost::math::isinf;
return isinf BOOST_PREVENT_MACRO_SUBSTITUTION (q.value());
}
template<class Unit,class Y>
inline
-bool
+bool
isnan BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
-{
+{
using boost::math::isnan;
return isnan BOOST_PREVENT_MACRO_SUBSTITUTION (q.value());
}
template<class Unit,class Y>
-inline
-bool
+inline
+bool
isnormal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
-{
+{
using boost::math::isnormal;
return isnormal BOOST_PREVENT_MACRO_SUBSTITUTION (q.value());
}
template<class Unit,class Y>
-inline
-bool
+inline
+bool
isgreater BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
-{
+{
using namespace detail;
return isgreater BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value());
}
template<class Unit,class Y>
-inline
-bool
+inline
+bool
isgreaterequal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
-{
+{
using namespace detail;
return isgreaterequal BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value());
}
template<class Unit,class Y>
-inline
-bool
+inline
+bool
isless BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
-{
+{
using namespace detail;
return isless BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value());
}
template<class Unit,class Y>
-inline
-bool
+inline
+bool
islessequal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
-{
+{
using namespace detail;
return islessequal BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value());
}
template<class Unit,class Y>
-inline
-bool
+inline
+bool
islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
-{
+{
using namespace detail;
return islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value());
}
template<class Unit,class Y>
-inline
-bool
+inline
+bool
isunordered BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
-{
+{
using namespace detail;
return isunordered BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value());
}
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
abs BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
using std::abs;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(abs BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
ceil BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
using std::ceil;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(ceil BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
copysign BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
{
using boost::math::copysign;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(copysign BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
}
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
fabs BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
using std::fabs;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(fabs BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
floor BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
using std::floor;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(floor BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
fdim BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
{
using namespace detail;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(fdim BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
}
#if 0
template<class Unit1,class Unit2,class Unit3,class Y>
-inline
+inline
typename add_typeof_helper<
typename multiply_typeof_helper<quantity<Unit1,Y>,
quantity<Unit2,Y> >::type,
- quantity<Unit3,Y> >::type
+ quantity<Unit3,Y> >::type
fma BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit1,Y>& q1,
const quantity<Unit2,Y>& q2,
const quantity<Unit3,Y>& q3)
@@ -232,53 +233,53 @@
typedef quantity<Unit1,Y> type1;
typedef quantity<Unit2,Y> type2;
typedef quantity<Unit3,Y> type3;
-
+
typedef typename multiply_typeof_helper<type1,type2>::type prod_type;
typedef typename add_typeof_helper<prod_type,type3>::type quantity_type;
-
+
return quantity_type::from_value(fma BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value(),q3.value()));
}
#endif
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
fmax BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
{
using namespace detail;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(fmax BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
}
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
fmin BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
{
using namespace detail;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(fmin BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
}
template<class Unit,class Y>
-inline
-int
+inline
+int
fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
-{
+{
using boost::math::fpclassify;
return fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION (q.value());
}
template<class Unit,class Y>
-inline
+inline
typename root_typeof_helper<
typename add_typeof_helper<
typename power_typeof_helper<quantity<Unit,Y>,
@@ -291,69 +292,69 @@
using boost::math::hypot;
typedef quantity<Unit,Y> type1;
-
+
typedef typename power_typeof_helper<type1,static_rational<2> >::type pow_type;
typedef typename add_typeof_helper<pow_type,pow_type>::type add_type;
typedef typename root_typeof_helper<add_type,static_rational<2> >::type quantity_type;
-
+
return quantity_type::from_value(hypot BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
}
// does ISO C++ support long long? g++ claims not
//template<class Unit,class Y>
-//inline
-//quantity<Unit,long long>
+//inline
+//quantity<Unit,long long>
//llrint BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
//{
// using namespace detail;
//
// typedef quantity<Unit,long long> quantity_type;
-//
+//
// return quantity_type::from_value(llrint BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
//}
// does ISO C++ support long long? g++ claims not
//template<class Unit,class Y>
-//inline
-//quantity<Unit,long long>
+//inline
+//quantity<Unit,long long>
//llround BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
//{
// using namespace detail;
//
// typedef quantity<Unit,long long> quantity_type;
-//
+//
// return quantity_type::from_value(llround BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
//}
#if 0
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
nearbyint BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
using namespace detail;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(nearbyint BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
#endif
template<class Unit,class Y>
-inline
+inline
quantity<Unit,Y> nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
{
using boost::math::nextafter;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
}
template<class Unit,class Y>
-inline
+inline
quantity<Unit,Y> nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
{
@@ -363,57 +364,57 @@
using boost::math::nextafter;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
}
#if 0
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
rint BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
using namespace detail;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(rint BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
#endif
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
round BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
using boost::math::round;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(round BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
template<class Unit,class Y>
-inline
-int
+inline
+int
signbit BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
-{
+{
using boost::math::signbit;
return signbit BOOST_PREVENT_MACRO_SUBSTITUTION (q.value());
}
template<class Unit,class Y>
-inline
-quantity<Unit,Y>
+inline
+quantity<Unit,Y>
trunc BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
using namespace detail;
typedef quantity<Unit,Y> quantity_type;
-
+
return quantity_type::from_value(trunc BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
@@ -423,7 +424,7 @@
fmod(const quantity<Unit,Y>& q1, const quantity<Unit,Y>& q2)
{
using std::fmod;
-
+
typedef quantity<Unit,Y> quantity_type;
return quantity_type::from_value(fmod(q1.value(), q2.value()));
@@ -453,7 +454,7 @@
return quantity_type::from_value(frexp(q.value(),ex));
}
-/// For non-dimensionless quantities, integral and rational powers
+/// For non-dimensionless quantities, integral and rational powers
/// and roots can be computed by @c pow<Ex> and @c root<Rt> respectively.
template<class S, class Y>
inline
@@ -517,7 +518,7 @@
}
template<class Unit,class Y>
-inline
+inline
typename root_typeof_helper<
quantity<Unit,Y>,
static_rational<2>
@@ -546,7 +547,7 @@
/// cos of theta in radians
template<class Y>
-typename dimensionless_quantity<si::system,Y>::type
+typename dimensionless_quantity<si::system,Y>::type
cos(const quantity<si::plane_angle,Y>& theta)
{
using std::cos;
@@ -555,7 +556,7 @@
/// sin of theta in radians
template<class Y>
-typename dimensionless_quantity<si::system,Y>::type
+typename dimensionless_quantity<si::system,Y>::type
sin(const quantity<si::plane_angle,Y>& theta)
{
using std::sin;
@@ -564,32 +565,32 @@
/// tan of theta in radians
template<class Y>
-typename dimensionless_quantity<si::system,Y>::type
+typename dimensionless_quantity<si::system,Y>::type
tan(const quantity<si::plane_angle,Y>& theta)
{
using std::tan;
return tan(theta.value());
}
-/// cos of theta in other angular units
+/// cos of theta in other angular units
template<class System,class Y>
-typename dimensionless_quantity<System,Y>::type
+typename dimensionless_quantity<System,Y>::type
cos(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
{
return cos(quantity<si::plane_angle,Y>(theta));
}
-/// sin of theta in other angular units
+/// sin of theta in other angular units
template<class System,class Y>
-typename dimensionless_quantity<System,Y>::type
+typename dimensionless_quantity<System,Y>::type
sin(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
{
return sin(quantity<si::plane_angle,Y>(theta));
}
-/// tan of theta in other angular units
+/// tan of theta in other angular units
template<class System,class Y>
-typename dimensionless_quantity<System,Y>::type
+typename dimensionless_quantity<System,Y>::type
tan(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
{
return tan(quantity<si::plane_angle,Y>(theta));
Modified: branches/units/autoprefix/boost/units/config.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/config.hpp (original)
+++ branches/units/autoprefix/boost/units/config.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -8,6 +8,12 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
+///
+/// \file
+/// \brief Boost units library configuration and Doxygen mainpage.
+/// \details BOOST_UNITS_HAS_BOOST_TYPEOF, BOOST_UNITS_REQUIRE_LAYOUT_COMPATIBILITY
+///
+
#ifndef BOOST_UNITS_CONFIG_HPP
#define BOOST_UNITS_CONFIG_HPP
@@ -22,13 +28,13 @@
///INTERNAL ONLY
#define BOOST_UNITS_HAS_BOOST_TYPEOF 0
#endif
-#endif
+#endif
#if (BOOST_UNITS_HAS_BOOST_TYPEOF)
- #include <boost/typeof/typeof.hpp>
+ #include <boost/typeof/typeof.hpp>
///INTERNAL ONLY
#define BOOST_UNITS_HAS_TYPEOF 1
-#else
+#else
#if (__GNUC__ && __cplusplus && __GNUC__ >= 3)
///INTERNAL ONLY
#define BOOST_UNITS_HAS_TYPEOF 1
@@ -90,7 +96,7 @@
/*! \mainpage Boost.Units
-A C++ library for zero-overhead dimensional analysis and
+A C++ library for zero-overhead dimensional analysis and
unit and quantity manipulation and conversion.
Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -102,11 +108,13 @@
This is a standalone index produced by the Doxygen Doxywizard GUI using information in the units/doc/doxygen/doxyfile.
A full index that includes the full documentation and tutorial is at
-http://www.boost.org/doc/libs/1_42_0/doc/html//boost_units.html.
+
+http://www.boost.org/doc/libs/1_42_0/libs/units/index.html
*/ // end mainpage
-/// Defined in jamfile.v2 line 30 during buildof documentation.
+/// Defined in jamfile.v2 line 30 during build of documentation,
+/// to ensure these macros are documented.
#ifdef BOOST_UNITS_DOXYGEN
/// If defined will trigger a static assertion if quantity<Unit, T>
Modified: branches/units/autoprefix/boost/units/conversion.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/conversion.hpp (original)
+++ branches/units/autoprefix/boost/units/conversion.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_CONVERSION_HPP
#define BOOST_UNITS_CONVERSION_HPP
+///
+/// \file
+/// \brief Template for defining conversions between quantities.
+///
+
#include <boost/units/detail/conversion_impl.hpp>
namespace boost {
@@ -22,6 +27,7 @@
#ifdef BOOST_UNITS_DOXYGEN
+/// \details
/// Template for defining conversions between
/// quantities. This template should be specialized
/// for every quantity that allows conversions.
Modified: branches/units/autoprefix/boost/units/derived_dimension.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/derived_dimension.hpp (original)
+++ branches/units/autoprefix/boost/units/derived_dimension.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_DERIVED_DIMENSION_HPP
#define BOOST_UNITS_DERIVED_DIMENSION_HPP
+///
+/// \file
+/// \brief Utility classes for defining composite and derived dimensions with integer powers.
+/// \details
+///
#include <boost/units/dim.hpp>
#include <boost/units/dimension.hpp>
#include <boost/units/static_rational.hpp>
@@ -35,7 +40,7 @@
#ifdef BOOST_UNITS_DOXYGEN
typedef detail::unspecified type;
#else
- typedef typename
+ typedef typename
make_dimension_list< list< dim< DT1,static_rational<E1> >,
list< dim< DT2,static_rational<E2> >,
list< dim< DT3,static_rational<E3> >,
@@ -59,7 +64,7 @@
dimensionless_type,0,
dimensionless_type,0>
{
- typedef typename
+ typedef typename
make_dimension_list< list< dim< DT1,static_rational<E1> >, dimensionless_type > >::type type;
};
@@ -76,7 +81,7 @@
dimensionless_type,0,
dimensionless_type,0>
{
- typedef typename
+ typedef typename
make_dimension_list< list< dim< DT1,static_rational<E1> >,
list< dim< DT2,static_rational<E2> >, dimensionless_type > > >::type type;
};
@@ -95,7 +100,7 @@
dimensionless_type,0,
dimensionless_type,0>
{
- typedef typename
+ typedef typename
make_dimension_list< list< dim< DT1,static_rational<E1> >,
list< dim< DT2,static_rational<E2> >,
list< dim< DT3,static_rational<E3> >, dimensionless_type > > > >::type type;
@@ -116,7 +121,7 @@
dimensionless_type,0,
dimensionless_type,0>
{
- typedef typename
+ typedef typename
make_dimension_list< list< dim< DT1,static_rational<E1> >,
list< dim< DT2,static_rational<E2> >,
list< dim< DT3,static_rational<E3> >,
@@ -139,7 +144,7 @@
dimensionless_type,0,
dimensionless_type,0>
{
- typedef typename
+ typedef typename
make_dimension_list< list< dim< DT1,static_rational<E1> >,
list< dim< DT2,static_rational<E2> >,
list< dim< DT3,static_rational<E3> >,
@@ -164,7 +169,7 @@
dimensionless_type,0,
dimensionless_type,0>
{
- typedef typename
+ typedef typename
make_dimension_list< list< dim< DT1,static_rational<E1> >,
list< dim< DT2,static_rational<E2> >,
list< dim< DT3,static_rational<E3> >,
@@ -191,7 +196,7 @@
DT7, E7,
dimensionless_type,0>
{
- typedef typename
+ typedef typename
make_dimension_list< list< dim< DT1,static_rational<E1> >,
list< dim< DT2,static_rational<E2> >,
list< dim< DT3,static_rational<E3> >,
@@ -203,6 +208,6 @@
} // namespace units
-} // namespace boost
+} // namespace boost
#endif // BOOST_UNITS_DERIVED_DIMENSION_HPP
Modified: branches/units/autoprefix/boost/units/dim.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/dim.hpp (original)
+++ branches/units/autoprefix/boost/units/dim.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,33 +11,13 @@
#ifndef BOOST_UNITS_DIM_HPP
#define BOOST_UNITS_DIM_HPP
-#include <boost/static_assert.hpp>
-
-#include <boost/type_traits/is_same.hpp>
-
-#include <boost/mpl/arithmetic.hpp>
-
-#include <boost/units/config.hpp>
-#include <boost/units/static_rational.hpp>
-#include <boost/units/detail/dim_impl.hpp>
-
-/// \file dim.hpp
-/// \brief Handling of fundamental dimension/exponent pairs.
-
-namespace boost {
-namespace units {
-namespace detail
-{
- struct dim_tag { };
-}
-
-/// \brief Dimension tag/exponent pair for a single fundamental dimension.
///
-/// \details
-/// The dim class represents a single dimension tag/dimension exponent pair.
+/// \file
+/// \brief Handling of fundamental dimension/exponent pairs.
+/// \details The dim class represents a single dimension tag/dimension exponent pair.
/// That is, @c dim<tag_type,value_type> is a pair where @c tag_type represents the
-/// fundamental dimension being represented and @c value_type represents the
-/// exponent of that fundamental dimension as a @c static_rational. @c tag_type must
+/// fundamental dimension being represented and @c value_type represents the
+/// exponent of that fundamental dimension as a @c static_rational. @c tag_type must
/// be a derived from a specialization of @c base_dimension.
/// Specialization of the following Boost.MPL metafunctions are provided
///
@@ -54,7 +34,26 @@
/// - @c mpl::divides for a @c static_rational and a @c dim in either order
///
/// These metafunctions likewise operate on the exponent only.
-template<typename T,typename V>
+///
+
+#include <boost/static_assert.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/mpl/arithmetic.hpp>
+
+#include <boost/units/config.hpp>
+#include <boost/units/static_rational.hpp>
+#include <boost/units/detail/dim_impl.hpp>
+
+namespace boost {
+namespace units {
+namespace detail
+{
+ struct dim_tag { };
+}
+
+template<typename T,typename V>
struct dim
{
typedef dim type;
@@ -81,7 +80,7 @@
namespace mpl {
-// define MPL operators acting on dim<T,V>
+/// define MPL operators acting on dim<T,V>
template<>
struct plus_impl<boost::units::detail::dim_tag,boost::units::detail::dim_tag>
Modified: branches/units/autoprefix/boost/units/dimension.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/dimension.hpp (original)
+++ branches/units/autoprefix/boost/units/dimension.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,26 +11,12 @@
#ifndef BOOST_UNITS_DIMENSION_HPP
#define BOOST_UNITS_DIMENSION_HPP
-#include <boost/static_assert.hpp>
-
-#include <boost/type_traits/is_same.hpp>
-
-#include <boost/mpl/arithmetic.hpp>
-
-#include <boost/units/static_rational.hpp>
-#include <boost/units/detail/dimension_list.hpp>
-#include <boost/units/detail/dimension_impl.hpp>
-
-/// \file
+///
+/// \file
/// \brief Core metaprogramming utilities for compile-time dimensional analysis.
-
-namespace boost {
-
-namespace units {
-
-/// Reduce dimension list to cardinal form. This algorithm collapses duplicate
+/// \details Reduce dimension list to cardinal form. This algorithm collapses duplicate
/// base dimension tags and sorts the resulting list by the tag ordinal value.
-/// Dimension lists that resolve to the same dimension are guaranteed to be
+/// Dimension lists that resolve to the same dimension are guaranteed to be
/// represented by an identical type.
///
/// The argument should be an MPL forward sequence containing instances
@@ -50,6 +36,22 @@
/// the exponents of the dimension by the static_rational.
/// - @c static_root takes a dimension and a static_rational and divides all
/// the exponents of the dimension by the static_rational.
+///
+
+#include <boost/static_assert.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/mpl/arithmetic.hpp>
+
+#include <boost/units/static_rational.hpp>
+#include <boost/units/detail/dimension_list.hpp>
+#include <boost/units/detail/dimension_impl.hpp>
+
+namespace boost {
+
+namespace units {
+
template<typename Seq>
struct make_dimension_list
{
@@ -57,23 +59,23 @@
};
/// Raise a dimension list to a scalar power.
-template<typename DL,typename Ex>
+template<typename DL,typename Ex>
struct static_power
{
typedef typename detail::static_power_impl<DL::size::value>::template apply<
DL,
Ex
- >::type type;
+ >::type type;
};
/// Take a scalar root of a dimension list.
-template<typename DL,typename Rt>
+template<typename DL,typename Rt>
struct static_root
{
typedef typename detail::static_root_impl<DL::size::value>::template apply<
DL,
Rt
- >::type type;
+ >::type type;
};
} // namespace units
Modified: branches/units/autoprefix/boost/units/dimensionless_quantity.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/dimensionless_quantity.hpp (original)
+++ branches/units/autoprefix/boost/units/dimensionless_quantity.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_DIMENSIONLESS_QUANTITY_HPP
#define BOOST_UNITS_DIMENSIONLESS_QUANTITY_HPP
+///
+/// \file
+/// \brief Utility class to simplify construction of dimensionless quantities.
+///
+
#include <boost/units/dimensionless_unit.hpp>
#include <boost/units/quantity.hpp>
@@ -18,7 +23,7 @@
namespace units {
-/// utility class to simplify construction of dimensionless quantities
+/// Utility class to simplify construction of dimensionless quantities.
template<class System,class Y>
struct dimensionless_quantity
{
Modified: branches/units/autoprefix/boost/units/dimensionless_type.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/dimensionless_type.hpp (original)
+++ branches/units/autoprefix/boost/units/dimensionless_type.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_DIMENSIONLESS_TYPE_HPP
#define BOOST_UNITS_DIMENSIONLESS_TYPE_HPP
+///
+/// \file
+/// \brief Dimension lists in which all exponents resolve to zero reduce to @c dimensionless_type.
+///
+
#include <boost/mpl/long.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/arithmetic.hpp>
@@ -42,9 +47,7 @@
#if BOOST_UNITS_HAS_BOOST_TYPEOF
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-BOOST_TYPEOF_REGISTER_TYPE(boost::units::dimensionless_type)
-
+ BOOST_TYPEOF_REGISTER_TYPE(boost::units::dimensionless_type)
#endif
#endif // BOOST_UNITS_DIMENSIONLESS_TYPE_HPP
Modified: branches/units/autoprefix/boost/units/dimensionless_unit.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/dimensionless_unit.hpp (original)
+++ branches/units/autoprefix/boost/units/dimensionless_unit.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_DIMENSIONLESS_UNIT_HPP
#define BOOST_UNITS_DIMENSIONLESS_UNIT_HPP
+///
+/// \file
+/// \brief Utility class to simplify construction of dimensionless units in a system.
+///
+
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/unit.hpp>
@@ -18,7 +23,7 @@
namespace units {
-/// utility class to simplify construction of dimensionless units in a system
+/// Utility class to simplify construction of dimensionless units in a system.
template<class System>
struct dimensionless_unit
{
Modified: branches/units/autoprefix/boost/units/get_dimension.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/get_dimension.hpp (original)
+++ branches/units/autoprefix/boost/units/get_dimension.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,12 @@
#ifndef BOOST_UNITS_GET_DIMENSION_HPP
#define BOOST_UNITS_GET_DIMENSION_HPP
+///
+/// \file
+/// \brief Get the dimension of a unit, absolute unit and quantity.
+/// \details
+///
+
#include <boost/units/units_fwd.hpp>
namespace boost {
@@ -20,21 +26,21 @@
template<class T>
struct get_dimension {};
-/// get the dimension of a unit
+/// Get the dimension of a unit.
template<class Dim,class System>
struct get_dimension< unit<Dim,System> >
{
typedef Dim type;
};
-/// get the dimension of an absolute unit
+/// Get the dimension of an absolute unit.
template<class Unit>
struct get_dimension< absolute<Unit> >
{
typedef typename get_dimension<Unit>::type type;
};
-/// get the dimension of a quantity
+/// Get the dimension of a quantity.
template<class Unit,class Y>
struct get_dimension< quantity<Unit,Y> >
{
Modified: branches/units/autoprefix/boost/units/get_system.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/get_system.hpp (original)
+++ branches/units/autoprefix/boost/units/get_system.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_GET_SYSTEM_HPP
#define BOOST_UNITS_GET_SYSTEM_HPP
+///
+/// \file
+/// \brief Get the system of a unit, absolute unit or quantity.
+///
+
#include <boost/units/units_fwd.hpp>
namespace boost {
@@ -20,21 +25,21 @@
template<class T>
struct get_system {};
-/// get the system of a unit
+/// Get the system of a unit.
template<class Dim,class System>
struct get_system< unit<Dim,System> >
{
typedef System type;
};
-/// get the system of an absolute unit
+/// Get the system of an absolute unit.
template<class Unit>
struct get_system< absolute<Unit> >
{
typedef typename get_system<Unit>::type type;
};
-/// get the system of a quantity
+/// Get the system of a quantity.
template<class Unit,class Y>
struct get_system< quantity<Unit,Y> >
{
Modified: branches/units/autoprefix/boost/units/heterogeneous_system.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/heterogeneous_system.hpp (original)
+++ branches/units/autoprefix/boost/units/heterogeneous_system.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,13 @@
#ifndef BOOST_UNITS_HETEROGENEOUS_SYSTEM_HPP
#define BOOST_UNITS_HETEROGENEOUS_SYSTEM_HPP
+///
+/// \file
+/// \brief A heterogeneous system is a sorted list of base unit/exponent pairs.
+/// \details As long as we don't need to convert heterogeneous systems
+/// directly everything is cool.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/times.hpp>
@@ -45,7 +52,7 @@
// A normal system is a sorted list of base units.
// A heterogeneous system is a sorted list of base unit/exponent pairs.
// As long as we don't need to convert heterogeneous systems
-// directly everything is cool
+// directly everything is cool.
template<class T>
struct is_zero : mpl::false_ {};
Modified: branches/units/autoprefix/boost/units/homogeneous_system.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/homogeneous_system.hpp (original)
+++ branches/units/autoprefix/boost/units/homogeneous_system.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,15 @@
#ifndef BOOST_UNITS_HOMOGENEOUS_SYSTEM_HPP_INCLUDED
#define BOOST_UNITS_HOMOGENEOUS_SYSTEM_HPP_INCLUDED
+///
+/// \file
+/// \brief Homogeneous systems.
+/// \details A system that can uniquely represent any unit
+/// which can be composed from a linearly independent set
+/// of base units. It is safe to rebind a unit with
+/// such a system to different dimensions.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/config.hpp>
@@ -29,11 +38,7 @@
namespace units {
-/// A system that can uniquely represent any unit
-/// which can be composed from a linearly independent set
-/// of base units. It is safe to rebind a unit with
-/// such a system to different dimensions.
-///
+
/// Do not construct this template directly. Use
/// make_system instead.
template<class L>
Modified: branches/units/autoprefix/boost/units/io.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/io.hpp (original)
+++ branches/units/autoprefix/boost/units/io.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,12 +11,13 @@
#ifndef BOOST_UNITS_IO_HPP
#define BOOST_UNITS_IO_HPP
+///
/// \file
-
-/// \brief Stream Input and output for rationals, units and quantities.
+/// \brief Stream input and output for rationals, units and quantities.
/// \details Functions and manipulators for output and input of units and quantities.
-/// symbol and name format, and engineering and binary autoprefix.
-/// Serialisation output is also supported.
+/// symbol and name format, and engineering and binary autoprefix.
+/// Serialisation output is also supported.
+///
#include <cassert>
#include <cmath>
@@ -38,7 +39,8 @@
namespace boost {
-namespace serialization {
+namespace serialization
+{ /// \namespace serialization for classes providing support for Boost Serialization library.
/// Boost Serialization library support for units.
template<class Archive,class System,class Dim>
@@ -51,7 +53,7 @@
{
ar & boost::serialization::make_nvp("value", units::quantity_cast<Y&>(q));
}
-
+
} // namespace serialization
namespace units {
@@ -59,8 +61,8 @@
/// get string representation of arbitrary type.
template<class T> std::string to_string(const T& t)
{
- std::stringstream sstr;
- sstr << t;
+ std::stringstream sstr;
+ sstr << t;
return sstr.str();
}
@@ -95,16 +97,16 @@
{
return(BaseUnit::name()); /// \returns BaseUnit::name(), for example "meter"
}
-
+
/// The symbol for the base unit.
-
+
static std::string symbol()
{
return(BaseUnit::symbol()); /// \returns BaseUnit::symbol(), for example "m"
}
};
-enum format_mode
+enum format_mode
{ /// \enum format_mode format of output of units, for example "m" or "meter".
symbol_fmt = 0, /// default - reduces unit names to known symbols for both base and derived units.
name_fmt = 1, /// output full unit names for base and derived units, for example "meter".
@@ -124,7 +126,7 @@
namespace detail {
template<bool>
-struct xalloc_key_holder
+struct xalloc_key_holder
{
static int value;
static bool initialized;
@@ -136,11 +138,11 @@
template<bool b>
bool xalloc_key_holder<b>::initialized = 0;
-struct xalloc_key_initializer_t
+struct xalloc_key_initializer_t
{
- xalloc_key_initializer_t()
+ xalloc_key_initializer_t()
{
- if (!xalloc_key_holder<true>::initialized)
+ if (!xalloc_key_holder<true>::initialized)
{
xalloc_key_holder<true>::value = std::ios_base::xalloc();
xalloc_key_holder<true>::initialized = true;
@@ -149,19 +151,19 @@
};
namespace /**/ {
-
+
xalloc_key_initializer_t xalloc_key_initializer;
} // namespace
} // namespace detail
-inline int get_flags(std::ios_base& ios, int mask)
+inline int get_flags(std::ios_base& ios, int mask)
{ /// \return flags controlling output.
return(ios.iword(detail::xalloc_key_holder<true>::value) & mask);
}
-inline void set_flags(std::ios_base& ios, int new_flags, int mask)
+inline void set_flags(std::ios_base& ios, int new_flags, int mask)
{ /// Set new flags controlling output format.
/// \return previous flags.
@@ -170,7 +172,7 @@
flags = (flags & ~mask) | static_cast<long>(new_flags);
}
-inline format_mode get_format(std::ios_base& ios)
+inline format_mode get_format(std::ios_base& ios)
{ /// \return flags controlling output format.
return(static_cast<format_mode>((get_flags)(ios, fmt_mask)));
}
@@ -180,26 +182,26 @@
(set_flags)(ios, new_mode, fmt_mask);
}
-inline std::ios_base& typename_format(std::ios_base& ios)
+inline std::ios_base& typename_format(std::ios_base& ios)
{ /// Set new flags for type_name output format.
/// \return previous format flags.
(set_format)(ios, typename_fmt);
return(ios);
}
-inline std::ios_base& raw_format(std::ios_base& ios)
+inline std::ios_base& raw_format(std::ios_base& ios)
{ /// set new flag for raw format output, for example "m".
(set_format)(ios, raw_fmt); /// \return previous format flags.
return(ios);
}
-inline std::ios_base& symbol_format(std::ios_base& ios)
+inline std::ios_base& symbol_format(std::ios_base& ios)
{ // set new format flag for symbol output, for example "m".
(set_format)(ios, symbol_fmt); /// \return previous format flags.
return(ios);
}
-inline std::ios_base& name_format(std::ios_base& ios)
+inline std::ios_base& name_format(std::ios_base& ios)
{ /// set new format for name output, for example "meter".
(set_format)(ios, name_fmt);
return(ios); /// \return previous format flags.
@@ -207,7 +209,7 @@
inline autoprefix_mode get_autoprefix(std::ios_base& ios)
{ /// get autoprefix flags for output.
-
+
return static_cast<autoprefix_mode>((get_flags)(ios, autoprefix_mask));
}
@@ -218,14 +220,14 @@
inline std::ios_base& no_prefix(std::ios_base& ios)
{ /// Clear autoprefix flags.
-
+
(set_autoprefix)(ios, autoprefix_none);
return ios; /// \return previous prefix flags.
}
inline std::ios_base& engineering_prefix(std::ios_base& ios)
{ /// Set flag for engineering prefix, so 1234.5 m displays as "1.2345 km".
-
+
(set_autoprefix)(ios, autoprefix_engineering);
return ios; /// \return previous prefix flags.
}
@@ -256,7 +258,7 @@
return base_unit_info<typename T::tag_type>::symbol() + exponent_string(typename T::value_type());
}
-template<class T>
+template<class T>
inline std::string base_unit_name_string(const T&)
{
return base_unit_info<typename T::tag_type>::name() + exponent_string(typename T::value_type());
@@ -306,12 +308,12 @@
};
template<int N>
-struct scale_symbol_string_impl
+struct scale_symbol_string_impl
{
template<class Begin>
- struct apply
+ struct apply
{
- static void value(std::string& str)
+ static void value(std::string& str)
{
str += Begin::item::symbol();
scale_symbol_string_impl<N - 1>::template apply<typename Begin::next>::value(str);
@@ -323,7 +325,7 @@
struct scale_symbol_string_impl<0>
{
template<class Begin>
- struct apply
+ struct apply
{
static void value(std::string&) { }
};
@@ -372,12 +374,12 @@
};
template<int N>
-struct scale_name_string_impl
+struct scale_name_string_impl
{
template<class Begin>
- struct apply
+ struct apply
{
- static void value(std::string& str)
+ static void value(std::string& str)
{
str += Begin::item::name();
scale_name_string_impl<N - 1>::template apply<typename Begin::next>::value(str);
@@ -389,7 +391,7 @@
struct scale_name_string_impl<0>
{
template<class Begin>
- struct apply
+ struct apply
{
static void value(std::string&) { }
};
@@ -453,14 +455,14 @@
f.template append_scale_to<Scale>(str);
std::string without_scale = f(unit<Dimension, heterogeneous_system<heterogeneous_system_impl<Units, Dimension, dimensionless_type> > >());
-
+
if (f.is_default_string(without_scale, unit<Dimension, heterogeneous_system<heterogeneous_system_impl<Units, Dimension, dimensionless_type> > >()))
{
str += "(";
str += without_scale;
str += ")";
- }
- else
+ }
+ else
{
str += without_scale;
}
@@ -774,14 +776,14 @@
std::string str;
std::string without_scale = f(unit<Dimension, heterogeneous_system<heterogeneous_system_impl<Units, Dimension, dimensionless_type> > >());
-
+
if (f.is_default_string(without_scale, unit<Dimension, heterogeneous_system<heterogeneous_system_impl<Units, Dimension, dimensionless_type> > >()))
{
str += "(";
str += without_scale;
str += ")";
- }
- else
+ }
+ else
{
str += without_scale;
}
@@ -945,27 +947,27 @@
template<class Char, class Traits, class Dimension, class System>
inline std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, const unit<Dimension, System>& u)
{
- if (units::get_format(os) == typename_fmt)
+ if (units::get_format(os) == typename_fmt)
{
detail::do_print(os, typename_string(u));
}
- else if (units::get_format(os) == raw_fmt)
+ else if (units::get_format(os) == raw_fmt)
{
detail::do_print(os, detail::to_string_impl(u, detail::format_raw_symbol_impl()));
}
- else if (units::get_format(os) == symbol_fmt)
+ else if (units::get_format(os) == symbol_fmt)
{
detail::do_print(os, symbol_string(u));
}
- else if (units::get_format(os) == name_fmt)
+ else if (units::get_format(os) == name_fmt)
{
detail::do_print(os, name_string(u));
}
- else
+ else
{
assert(!"The format mode must be one of: typename_format, raw_format, name_format, symbol_format");
}
-
+
return(os);
}
Modified: branches/units/autoprefix/boost/units/is_dim.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_dim.hpp (original)
+++ branches/units/autoprefix/boost/units/is_dim.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_DIM_HPP
#define BOOST_UNITS_IS_DIM_HPP
+///
+/// \file
+/// \brief Check that a type is a valid @c dim.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
@@ -20,7 +25,7 @@
namespace units {
/// Check that a type is a valid @c dim.
-template<typename T>
+template<typename T>
struct is_dim :
public mpl::false_
{ };
Modified: branches/units/autoprefix/boost/units/is_dimension_list.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_dimension_list.hpp (original)
+++ branches/units/autoprefix/boost/units/is_dimension_list.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_DIMENSION_LIST_HPP
#define BOOST_UNITS_IS_DIMENSION_LIST_HPP
+///
+/// \file
+/// \brief Check that a type is a valid dimension list.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
Modified: branches/units/autoprefix/boost/units/is_dimensionless.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_dimensionless.hpp (original)
+++ branches/units/autoprefix/boost/units/is_dimensionless.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,6 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+
+
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +13,11 @@
#ifndef BOOST_UNITS_IS_DIMENSIONLESS_HPP
#define BOOST_UNITS_IS_DIMENSIONLESS_HPP
+///
+/// \file
+/// \brief Check if a unit or quantity is dimensionless.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
@@ -23,13 +30,13 @@
public mpl::false_
{ };
-/// check if a unit is dimensionless
+/// Check if a unit is dimensionless.
template<class System>
struct is_dimensionless< unit<dimensionless_type,System> > :
public mpl::true_
{ };
-/// check if a quantity is dimensionless
+/// Check if a quantity is dimensionless.
template<class Unit,class Y>
struct is_dimensionless< quantity<Unit,Y> > :
public is_dimensionless<Unit>
Modified: branches/units/autoprefix/boost/units/is_dimensionless_quantity.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_dimensionless_quantity.hpp (original)
+++ branches/units/autoprefix/boost/units/is_dimensionless_quantity.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_DIMENSIONLESS_QUANTITY_HPP
#define BOOST_UNITS_IS_DIMENSIONLESS_QUANTITY_HPP
+///
+/// \file
+/// \brief check that a type is a dimensionless quantity
+///
+
#include <boost/units/is_quantity_of_dimension.hpp>
#include <boost/units/units_fwd.hpp>
@@ -18,7 +23,7 @@
namespace units {
-/// check that a type is a dimensionless quantity
+/// Check that a type is a dimensionless quantity.
template<class T>
struct is_dimensionless_quantity :
public is_quantity_of_dimension<T,dimensionless_type>
Modified: branches/units/autoprefix/boost/units/is_dimensionless_unit.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_dimensionless_unit.hpp (original)
+++ branches/units/autoprefix/boost/units/is_dimensionless_unit.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_DIMENSIONLESS_UNIT_HPP
#define BOOST_UNITS_IS_DIMENSIONLESS_UNIT_HPP
+///
+/// \file
+/// \brief Check that a type is a dimensionless unit.
+///
+
#include <boost/units/is_unit_of_dimension.hpp>
#include <boost/units/units_fwd.hpp>
@@ -18,7 +23,7 @@
namespace units {
-/// check that a type is a dimensionless unit
+/// Check that a type is a dimensionless unit.
template<class T>
struct is_dimensionless_unit :
public is_unit_of_dimension<T,dimensionless_type>
Modified: branches/units/autoprefix/boost/units/is_quantity.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_quantity.hpp (original)
+++ branches/units/autoprefix/boost/units/is_quantity.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_QUANTITY_HPP
#define BOOST_UNITS_IS_QUANTITY_HPP
+///
+/// \file
+/// \brief Check that a type is a quantity.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
@@ -18,7 +23,7 @@
namespace units {
-/// check that a type is a quantity
+/// Check that a type is a quantity.
template<typename T>
struct is_quantity :
public mpl::false_
@@ -26,7 +31,7 @@
template<class Unit,
class Y>
-struct is_quantity< quantity<Unit,Y> > :
+struct is_quantity< quantity<Unit,Y> > :
public mpl::true_
{ };
Modified: branches/units/autoprefix/boost/units/is_quantity_of_dimension.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_quantity_of_dimension.hpp (original)
+++ branches/units/autoprefix/boost/units/is_quantity_of_dimension.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_QUANTITY_OF_DIMENSION_HPP
#define BOOST_UNITS_IS_QUANTITY_OF_DIMENSION_HPP
+///
+/// \file
+/// \brief Check that a type is a quantity of the specified dimension.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
#include <boost/units/is_unit_of_dimension.hpp>
@@ -19,7 +24,7 @@
namespace units {
-/// check that a type is a quantity of the specified dimension
+/// Check that a type is a quantity of the specified dimension.
template<class T,class Dim>
struct is_quantity_of_dimension :
public mpl::false_
Modified: branches/units/autoprefix/boost/units/is_quantity_of_system.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_quantity_of_system.hpp (original)
+++ branches/units/autoprefix/boost/units/is_quantity_of_system.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_QUANTITY_OF_SYSTEM_HPP
#define BOOST_UNITS_IS_QUANTITY_OF_SYSTEM_HPP
+///
+/// \file
+/// \brief Check that a type is a quantity in a specified system.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
#include <boost/units/is_unit_of_system.hpp>
@@ -19,7 +24,7 @@
namespace units {
-/// check that a type is a quantity in a specified system
+/// Check that a type is a quantity in a specified system.
template<class T,class System>
struct is_quantity_of_system :
public mpl::false_
Modified: branches/units/autoprefix/boost/units/is_unit.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_unit.hpp (original)
+++ branches/units/autoprefix/boost/units/is_unit.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_UNIT_HPP
#define BOOST_UNITS_IS_UNIT_HPP
+///
+/// \file
+/// \brief Check that a type is a unit.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
@@ -18,9 +23,9 @@
namespace units {
-/// check that a type is a unit
+/// Check that a type is a unit.
template<class T>
-struct is_unit :
+struct is_unit :
public mpl::false_
{ };
Modified: branches/units/autoprefix/boost/units/is_unit_of_dimension.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_unit_of_dimension.hpp (original)
+++ branches/units/autoprefix/boost/units/is_unit_of_dimension.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_UNIT_OF_DIMENSION_HPP
#define BOOST_UNITS_IS_UNIT_OF_DIMENSION_HPP
+///
+/// \file
+/// \brief Check that a type is a unit of the specified dimension.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
@@ -18,7 +23,7 @@
namespace units {
-/// check that a type is a unit of the specified dimension
+/// Check that a type is a unit of the specified dimension.
template<class T,class Dim>
struct is_unit_of_dimension :
public mpl::false_
Modified: branches/units/autoprefix/boost/units/is_unit_of_system.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/is_unit_of_system.hpp (original)
+++ branches/units/autoprefix/boost/units/is_unit_of_system.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_IS_UNIT_OF_SYSTEM_HPP
#define BOOST_UNITS_IS_UNIT_OF_SYSTEM_HPP
+///
+/// \file
+/// \brief Check that a type is a unit in a specified system.
+///
+
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
@@ -18,17 +23,17 @@
namespace units {
-/// check that a type is a unit in a specified system
+/// Check that a type is a unit in a specified system.
template<class T,class System>
struct is_unit_of_system :
public mpl::false_
{ };
-
+
template<class Dim,class System>
struct is_unit_of_system< unit<Dim,System>,System > :
public mpl::true_
{ };
-
+
template<class Dim,class System>
struct is_unit_of_system< absolute<unit<Dim,System> >,System > :
public mpl::true_
Modified: branches/units/autoprefix/boost/units/lambda.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/lambda.hpp (original)
+++ branches/units/autoprefix/boost/units/lambda.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -13,7 +13,6 @@
#ifndef BOOST_UNITS_LAMBDA_HPP
#define BOOST_UNITS_LAMBDA_HPP
-
////////////////////////////////////////////////////////////////////////
///
/// \file lambda.hpp
@@ -25,7 +24,7 @@
/// \author Torsten Maehne
/// \date 2008-06-16
///
-/// Boost.Lambda's return type deduction system is extented to make
+/// \details Boost.Lambda's return type deduction system is extented to make
/// use of Boost.Units' typeof_helper trait classes for Boost.Units'
/// quantity, absolute, and unit template classes.
///
@@ -519,7 +518,7 @@
} // namespace lambda
namespace units {
-
+
template<typename System, typename Dim, typename Arg>
struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > > {
typedef boost::lambda::lambda_functor<
@@ -561,7 +560,7 @@
} // namespace lambda
namespace units {
-
+
template<typename System, typename Dim, typename Arg>
struct multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> > {
typedef boost::lambda::lambda_functor<
Modified: branches/units/autoprefix/boost/units/limits.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/limits.hpp (original)
+++ branches/units/autoprefix/boost/units/limits.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -7,9 +7,15 @@
// 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_LIMITS_HPP
#define BOOST_UNITS_LIMITS_HPP
+///
+/// \file
+/// \brief specialize std::numeric_limits for units.
+///
+
#include <limits>
#include <boost/units/units_fwd.hpp>
Modified: branches/units/autoprefix/boost/units/make_scaled_unit.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/make_scaled_unit.hpp (original)
+++ branches/units/autoprefix/boost/units/make_scaled_unit.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_MAKE_SCALED_UNIT_HPP_INCLUDED
#define BOOST_UNITS_MAKE_SCALED_UNIT_HPP_INCLUDED
+///
+/// \file
+/// \brief Make scaled unit.
+///
+
#include <boost/units/units_fwd.hpp>
#include <boost/units/heterogeneous_system.hpp>
#include <boost/units/unit.hpp>
Modified: branches/units/autoprefix/boost/units/make_system.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/make_system.hpp (original)
+++ branches/units/autoprefix/boost/units/make_system.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,18 @@
#ifndef BOOST_UNITS_MAKE_SYSTEM_HPP
#define BOOST_UNITS_MAKE_SYSTEM_HPP
+///
+/// \file
+/// \brief Metafunction returning a homogeneous system that can
+/// represent any combination of the base units.
+/// \details
+/// Metafunction make_system returning a homogeneous system that can
+/// represent any combination of the base units. There must
+/// be no way to represent any of the base units in terms
+/// of the others. make_system<foot_base_unit, meter_base_unit>::type
+/// is not allowed, for example.
+///
+
#include <boost/units/config.hpp>
#include <boost/units/dimensionless_type.hpp>
#include <boost/units/homogeneous_system.hpp>
@@ -29,7 +41,7 @@
}
-/// Metafunction returning a homogeneous system that can
+/// Metafunction make_system returning a homogeneous system that can
/// represent any combination of the base units. There must
/// be no way to represent any of the base units in terms
/// of the others. make_system<foot_base_unit, meter_base_unit>::type
Modified: branches/units/autoprefix/boost/units/operators.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/operators.hpp (original)
+++ branches/units/autoprefix/boost/units/operators.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -8,23 +8,25 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_UNITS_OPERATORS_HPP
+#ifndef BOOST_UNITS_OPERATORS_HPP
#define BOOST_UNITS_OPERATORS_HPP
+
+///
+/// \file
+/// \brief Compile time operators and typeof helper classes.
+/// \details
+/// These operators declare the compile-time operators needed to support dimensional
+/// analysis algebra. They require the use of Boost.Typeof, emulation or native.
+/// Typeof helper classes define result type for heterogeneous operators on value types.
+/// These must be defined through specialization for powers and roots.
+///
+
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/units/config.hpp>
-/// \file operators.hpp
-/// \brief Compile time operators and typeof helper classes.
-///
-/// \details
-/// These operators declare the compile-time operators needed to support dimensional
-/// analysis algebra. They require the use of Boost.Typeof, emulation or native.
-/// Typeof helper classes define result type for heterogeneous operators on value types.
-/// These must be defined through specialization for powers and roots.
-
namespace boost {
namespace units {
@@ -44,37 +46,37 @@
#if (BOOST_UNITS_HAS_BOOST_TYPEOF)
-template<typename X> struct unary_plus_typeof_helper
+template<typename X> struct unary_plus_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (+typeof_::make<X>()))
typedef typename nested::type type;
};
-template<typename X> struct unary_minus_typeof_helper
+template<typename X> struct unary_minus_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (-typeof_::make<X>()))
typedef typename nested::type type;
};
-template<typename X,typename Y> struct add_typeof_helper
+template<typename X,typename Y> struct add_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (typeof_::make<X>()+typeof_::make<Y>()))
typedef typename nested::type type;
};
-template<typename X,typename Y> struct subtract_typeof_helper
+template<typename X,typename Y> struct subtract_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (typeof_::make<X>()-typeof_::make<Y>()))
typedef typename nested::type type;
};
-template<typename X,typename Y> struct multiply_typeof_helper
+template<typename X,typename Y> struct multiply_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (typeof_::make<X>()*typeof_::make<Y>()))
typedef typename nested::type type;
};
-template<typename X,typename Y> struct divide_typeof_helper
+template<typename X,typename Y> struct divide_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (typeof_::make<X>()/typeof_::make<Y>()))
typedef typename nested::type type;
Modified: branches/units/autoprefix/boost/units/physical_dimensions.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/physical_dimensions.hpp (original)
+++ branches/units/autoprefix/boost/units/physical_dimensions.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,15 +11,12 @@
#ifndef BOOST_UNITS_PHYSICAL_UNITS_HPP
#define BOOST_UNITS_PHYSICAL_UNITS_HPP
-/// \file
-
-/// \brief Physical dimensions according to the SI system.
///
+/// \file
+/// \brief Physical dimensions according to the SI system.
/// \details This header includes all physical dimension headers for both base
-/// derived dimensions.
-
-/// Base dimensions are extended to include plane and solid angle as separate dimensions
-/// to reduce the risk of confusion between the dimensions.
+/// and derived dimensions.
+///
// Include all of the physical_dimension headers.
@@ -32,7 +29,7 @@
#include <boost/units/physical_dimensions/temperature.hpp>
#include <boost/units/physical_dimensions/time.hpp>
-// Base dimensions are extended to include plane and solid angle for convenience.
+// Base dimensions are extended to include plane and solid angle for convenience.
#include <boost/units/physical_dimensions/plane_angle.hpp>
#include <boost/units/physical_dimensions/solid_angle.hpp>
Modified: branches/units/autoprefix/boost/units/pow.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/pow.hpp (original)
+++ branches/units/autoprefix/boost/units/pow.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -8,7 +8,7 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_UNITS_POW_HPP
+#ifndef BOOST_UNITS_POW_HPP
#define BOOST_UNITS_POW_HPP
#include <boost/math_fwd.hpp>
@@ -18,8 +18,10 @@
#include <boost/units/static_rational.hpp>
#include <boost/units/detail/static_rational_power.hpp>
-/// \file pow.hpp
+///
+/// \file
/// \brief Raise values to exponents known at compile-time.
+///
namespace boost {
@@ -44,21 +46,21 @@
#ifndef BOOST_UNITS_DOXYGEN
/// raise @c T to a @c static_rational power.
-template<class T, long N,long D>
-struct power_typeof_helper<T, static_rational<N,D> >
-{
+template<class T, long N,long D>
+struct power_typeof_helper<T, static_rational<N,D> >
+{
typedef typename mpl::if_<boost::is_integral<T>, double, T>::type internal_type;
typedef detail::static_rational_power_impl<static_rational<N, D>, internal_type> impl;
- typedef typename impl::type type;
-
- static type value(const T& x)
+ typedef typename impl::type type;
+
+ static type value(const T& x)
{
return impl::call(x);
}
};
/// raise @c float to a @c static_rational power.
-template<long N,long D>
+template<long N,long D>
struct power_typeof_helper<float, static_rational<N,D> >
{
// N.B. pathscale doesn't accept inheritance for some reason.
@@ -91,7 +93,7 @@
#ifndef BOOST_UNITS_DOXYGEN
/// take @c static_rational root of an @c T
-template<class T, long N,long D>
+template<class T, long N,long D>
struct root_typeof_helper<T,static_rational<N,D> >
{
// N.B. pathscale doesn't accept inheritance for some reason.
Modified: branches/units/autoprefix/boost/units/quantity.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/quantity.hpp (original)
+++ branches/units/autoprefix/boost/units/quantity.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,12 @@
#ifndef BOOST_UNITS_QUANTITY_HPP
#define BOOST_UNITS_QUANTITY_HPP
+///
+/// \file
+/// \brief unit class assingment and conversions.
+/// \details
+///
+
#include <algorithm>
#include <boost/config.hpp>
@@ -72,7 +78,7 @@
template<>
struct is_non_narrowing_conversion<long double, double> : mpl::false_ {};
-// msvc 7.1 needs extra disambiguation
+// msvc 7.1 needs extra disambiguation.
template<class T, class U>
struct disable_if_is_same
{
@@ -83,36 +89,36 @@
struct disable_if_is_same<T, T> {};
}
-
-/// class declaration
+
+/// Quantity of Unit class and conversions permitted.
template<class Unit,class Y = double>
class quantity
{
- // base units are not the same as units.
+ // 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_()
- {
+
+ quantity() : val_()
+ {
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
- quantity(unspecified_null_pointer_constant_type) : val_()
- {
+ quantity(unspecified_null_pointer_constant_type) : val_()
+ {
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
-
- quantity(const this_type& source) : val_(source.val_)
+
+ 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.
@@ -121,66 +127,66 @@
unit_type force_unit_instantiation;
}
#endif
-
+
//~quantity() { }
-
- this_type& operator=(const this_type& source)
- {
- val_ = source.val_;
-
- return *this;
+
+ 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
+ /// 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
+ /// 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
+ /// 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
+
+ /// 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 conversion between different unit systems is allowed if implicit conversion is disallowed.
+ template<class Unit2,class YY>
explicit
- quantity(const quantity<Unit2,YY>& source,
+ quantity(const quantity<Unit2,YY>& source,
typename boost::disable_if<
mpl::and_<
//is_implicitly_convertible should be undefined when the
@@ -196,9 +202,9 @@
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,
+ /// 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,
@@ -214,9 +220,9 @@
#else
- /// without SFINAE we can't distinguish between explicit and implicit conversions so
+ /// without SFINAE we can't distinguish between explicit and implicit conversions so
/// the conversion is always explicit
- template<class Unit2,class YY>
+ template<class Unit2,class YY>
explicit quantity(const quantity<Unit2,YY>& source)
: val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
{
@@ -225,22 +231,22 @@
}
#endif
-
- /// implicit assignment between different unit systems is allowed if each fundamental dimension is implicitly convertible
+
+ /// 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)
@@ -248,7 +254,7 @@
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>
@@ -257,7 +263,7 @@
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)
@@ -265,8 +271,8 @@
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)
{
@@ -279,18 +285,19 @@
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
+/// Quantity of dimensionless quantities and conversion permitted.
+/// 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.
@@ -299,37 +306,37 @@
{
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_()
+
+ quantity() : val_()
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
-
+
/// construction from raw @c value_type is allowed
- quantity(value_type val) : val_(val)
+ quantity(value_type val) : val_(val)
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
- }
-
- quantity(const this_type& source) : val_(source.val_)
+ }
+
+ 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;
+
+ 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
@@ -337,7 +344,7 @@
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);
}
@@ -346,7 +353,7 @@
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);
}
@@ -356,13 +363,13 @@
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)
@@ -370,21 +377,21 @@
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>
+ 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,
@@ -392,20 +399,20 @@
typename boost::enable_if<detail::is_dimensionless_system<System2> >::type* = 0
#endif
) :
- val_(source.value())
+ val_(source.value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
/// implicit conversion between different unit systems is allowed
- template<class System2, class Y2>
+ 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,
@@ -413,7 +420,7 @@
typename boost::enable_if<detail::is_dimensionless_system<System2> >::type* = 0
#endif
) :
- val_(static_cast<Y>(source.value()))
+ val_(static_cast<Y>(source.value()))
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
@@ -421,9 +428,9 @@
#else
/// implicit conversion between different unit systems is allowed
- template<class System2, class Y2>
+ template<class System2, class Y2>
quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source) :
- val_(source.value())
+ val_(source.value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
BOOST_STATIC_ASSERT((boost::is_convertible<Y2, Y>::value == true));
@@ -433,14 +440,14 @@
/// conversion between different unit systems is explicit when
/// the units are not equivalent.
- template<class System2, class Y2>
+ 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())
+ 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
@@ -448,28 +455,28 @@
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; }
-
+ 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; }
-
+ 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; }
+ 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; }
+ 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); }
@@ -512,7 +519,7 @@
struct quantity_cast_helper<Y,quantity<Unit,X> >
{
typedef Y type;
-
+
type operator()(quantity<Unit,X>& source) { return const_cast<X&>(source.value()); }
};
@@ -521,7 +528,7 @@
struct quantity_cast_helper<Y,const quantity<Unit,X> >
{
typedef Y type;
-
+
type operator()(const quantity<Unit,X>& source) { return source.value(); }
};
@@ -529,22 +536,22 @@
/// quantity_cast provides mutating access to underlying quantity value_type
template<class X,class Y>
-inline
+inline
X
quantity_cast(Y& source)
{
detail::quantity_cast_helper<X,Y> qch;
-
+
return qch(source);
}
template<class X,class Y>
-inline
+inline
X
quantity_cast(const Y& source)
{
detail::quantity_cast_helper<X,const Y> qch;
-
+
return qch(source);
}
@@ -820,30 +827,30 @@
/// 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> >
-{
+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)
- {
+ 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> >
-{
+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)
- {
+
+ static type value(const quantity<Unit,Y>& x)
+ {
return type::from_value(root_typeof_helper<Y,static_rational<N,D> >::value(x.value()));
}
};
@@ -858,7 +865,7 @@
operator*(const unit<Dim,System>&,const Y& rhs)
{
typedef typename multiply_typeof_helper< unit<Dim,System>,Y >::type type;
-
+
return type::from_value(rhs);
}
@@ -871,7 +878,7 @@
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);
}
@@ -884,7 +891,7 @@
operator*(const Y& lhs,const unit<Dim,System>&)
{
typedef typename multiply_typeof_helper< Y,unit<Dim,System> >::type type;
-
+
return type::from_value(lhs);
}
@@ -897,7 +904,7 @@
operator/(const Y& lhs,const unit<Dim,System>&)
{
typedef typename divide_typeof_helper< Y,unit<Dim,System> >::type type;
-
+
return type::from_value(lhs);
}
@@ -910,7 +917,7 @@
//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);
//}
//
@@ -923,7 +930,7 @@
//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());
//}
@@ -935,7 +942,7 @@
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);
}
@@ -947,7 +954,7 @@
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());
}
@@ -960,7 +967,7 @@
//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);
//}
//
@@ -973,7 +980,7 @@
//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());
//}
@@ -985,7 +992,7 @@
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);
}
@@ -997,7 +1004,7 @@
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());
}
@@ -1011,7 +1018,7 @@
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());
}
@@ -1025,7 +1032,7 @@
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());
}
@@ -1039,7 +1046,7 @@
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());
}
@@ -1053,7 +1060,7 @@
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());
}
@@ -1061,9 +1068,9 @@
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());
}
@@ -1071,9 +1078,9 @@
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());
}
@@ -1088,7 +1095,7 @@
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());
}
@@ -1103,7 +1110,7 @@
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());
}
@@ -1119,7 +1126,7 @@
{
typedef typename multiply_typeof_helper< quantity<Unit1,X>,
quantity<Unit2,Y> >::type type;
-
+
return type::from_value(lhs.value()*rhs.value());
}
@@ -1135,7 +1142,7 @@
{
typedef typename divide_typeof_helper< quantity<Unit1,X>,
quantity<Unit2,Y> >::type type;
-
+
return type::from_value(lhs.value()/rhs.value());
}
@@ -1144,7 +1151,7 @@
class X,
class Y>
inline
-bool
+bool
operator==(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
{
@@ -1156,7 +1163,7 @@
class X,
class Y>
inline
-bool
+bool
operator!=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
{
@@ -1168,7 +1175,7 @@
class X,
class Y>
inline
-bool
+bool
operator<(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
{
@@ -1180,7 +1187,7 @@
class X,
class Y>
inline
-bool
+bool
operator<=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
{
@@ -1192,7 +1199,7 @@
class X,
class Y>
inline
-bool
+bool
operator>(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
{
@@ -1204,7 +1211,7 @@
class X,
class Y>
inline
-bool
+bool
operator>=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
{
Modified: branches/units/autoprefix/boost/units/reduce_unit.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/reduce_unit.hpp (original)
+++ branches/units/autoprefix/boost/units/reduce_unit.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,11 @@
#ifndef BOOST_UNITS_REDUCE_UNIT_HPP_INCLUDED
#define BOOST_UNITS_REDUCE_UNIT_HPP_INCLUDED
+///
+/// \file
+/// \brief Returns a unique type for every unit.
+///
+
namespace boost {
namespace units {
Modified: branches/units/autoprefix/boost/units/scale.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/scale.hpp (original)
+++ branches/units/autoprefix/boost/units/scale.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,13 @@
#ifndef BOOST_UNITS_SCALE_HPP_INCLUDED
#define BOOST_UNITS_SCALE_HPP_INCLUDED
+///
+/// \file
+/// \brief 10^3 Engineering & 2^10 binary scaling factors for autoprefixing.
+/// \details
+/// \author Steven Watanabe
+///
+
#include <string>
#include <boost/units/config.hpp>
@@ -26,8 +33,8 @@
template<class S, class Scale>
struct scaled_base_unit;
-/// class representing a scaling factor such as 10^3
-/// The exponent should be a static rational.
+/// scale class representing a scaling factor such as 10^3
+/// The exponent must be a static rational.
template<long Base, class Exponent>
struct scale
{
Modified: branches/units/autoprefix/boost/units/scaled_base_unit.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/scaled_base_unit.hpp (original)
+++ branches/units/autoprefix/boost/units/scaled_base_unit.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,12 @@
#ifndef BOOST_UNITS_SCALED_BASE_UNIT_HPP_INCLUDED
#define BOOST_UNITS_SCALED_BASE_UNIT_HPP_INCLUDED
+///
+/// \file
+/// \brief Scaled base unit.
+/// \details INTERNAL ONLY.
+///
+
#include <string>
#include <boost/mpl/bool.hpp>
Modified: branches/units/autoprefix/boost/units/static_constant.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/static_constant.hpp (original)
+++ branches/units/autoprefix/boost/units/static_constant.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,10 +11,15 @@
#ifndef BOOST_UNITS_STATIC_CONSTANT_HPP
#define BOOST_UNITS_STATIC_CONSTANT_HPP
+///
+/// \file
+/// \brief Macro for static constants with auto type deduction
+/// \details A convenience macro that allows definition of static
+/// constants in headers in an ODR-safe way.
+///
+
#include <boost/units/config.hpp>
-/// A convenience macro that allows definition of static
-/// constants in headers in an ODR-safe way.
#define BOOST_UNITS_STATIC_CONSTANT(name, type) \
template<bool b> \
struct name##_instance_t \
@@ -30,8 +35,8 @@
template<bool b> \
const type name##_instance_t<b>::instance
-/// A convenience macro for static constants with auto
-/// type deduction.
+/// A convenience macro for static constants with auto
+/// type deduction.
#if BOOST_UNITS_HAS_TYPEOF
#if BOOST_UNITS_HAS_BOOST_TYPEOF
Modified: branches/units/autoprefix/boost/units/static_rational.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/static_rational.hpp (original)
+++ branches/units/autoprefix/boost/units/static_rational.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -46,8 +46,9 @@
BOOST_STATIC_CONSTANT(integer_type,value = Value < 0 ? -Value : Value);
};
-/// Compile time rational number.
-/**
+// Compile time rational number.
+
+/*! \details
This is an implementation of a compile time rational number, where @c static_rational<N,D> represents
a rational number with numerator @c N and denominator @c D. Because of the potential for ambiguity arising
from multiple equivalent values of @c static_rational (e.g. @c static_rational<6,2>==static_rational<3>),
Modified: branches/units/autoprefix/boost/units/unit.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/unit.hpp (original)
+++ branches/units/autoprefix/boost/units/unit.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,6 +11,12 @@
#ifndef BOOST_UNITS_UNIT_HPP
#define BOOST_UNITS_UNIT_HPP
+///
+/// \file
+/// \brief unit classes and functions.
+/// \details unit representing a model-dependent unit with no associated value for dimensional analysis.
+///
+
#include <boost/static_assert.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/assert.hpp>
@@ -28,26 +34,24 @@
namespace boost {
-namespace units {
-
-/// class representing a model-dependent unit with no associated value
+namespace units { //! \namespace boost::units::detail \brief unit classes and functions implementation details (not recommended for normal use).
-/// (e.g. meters, Kelvin, feet, etc...)
template<class Dim,class System, class Enable>
class unit
-{
+{ /// \brief unit representing a model-dependent unit with no associated value.
+ /// \details (for example: meters, Kelvin, feet, etc...). Can be used for dimensional analysis.
public:
typedef unit<Dim, System> unit_type;
typedef unit<Dim,System> this_type;
- typedef Dim dimension_type;
+ typedef Dim dimension_type;
typedef System system_type;
-
+
unit() { }
unit(const this_type&) { }
- //~unit() { }
-
+ //~unit() { }
+
this_type& operator=(const this_type&) { }
-
+
// sun will ignore errors resulting from templates
// instantiated in the return type of a function.
// Make sure that we get an error anyway by putting.
@@ -94,7 +98,7 @@
};
/// INTERNAL ONLY
-template<class S1,class S2>
+template<class S1,class S2>
struct is_implicitly_convertible :
boost::is_same<typename reduce_unit<S1>::type, typename reduce_unit<S2>::type>
{ };
@@ -300,25 +304,25 @@
};
/// raise unit to a @c static_rational power
-template<class Dim,class System,long N,long D>
-struct power_typeof_helper<unit<Dim,System>,static_rational<N,D> >
-{
- typedef unit<typename static_power<Dim,static_rational<N,D> >::type,typename static_power<System, static_rational<N,D> >::type> type;
-
- static type value(const unit<Dim,System>&)
- {
+template<class Dim,class System,long N,long D>
+struct power_typeof_helper<unit<Dim,System>,static_rational<N,D> >
+{
+ typedef unit<typename static_power<Dim,static_rational<N,D> >::type,typename static_power<System, static_rational<N,D> >::type> type;
+
+ static type value(const unit<Dim,System>&)
+ {
return type();
}
};
/// take the @c static_rational root of a unit
-template<class Dim,class System,long N,long D>
-struct root_typeof_helper<unit<Dim,System>,static_rational<N,D> >
-{
- typedef unit<typename static_root<Dim,static_rational<N,D> >::type,typename static_root<System, static_rational<N,D> >::type> type;
-
- static type value(const unit<Dim,System>&)
- {
+template<class Dim,class System,long N,long D>
+struct root_typeof_helper<unit<Dim,System>,static_rational<N,D> >
+{
+ typedef unit<typename static_root<Dim,static_rational<N,D> >::type,typename static_root<System, static_rational<N,D> >::type> type;
+
+ static type value(const unit<Dim,System>&)
+ {
return type();
}
};
@@ -327,9 +331,9 @@
template<class Dim,class System>
typename unary_plus_typeof_helper< unit<Dim,System> >::type
operator+(const unit<Dim,System>&)
-{
+{
typedef typename unary_plus_typeof_helper< unit<Dim,System> >::type type;
-
+
return type();
}
@@ -337,9 +341,9 @@
template<class Dim,class System>
typename unary_minus_typeof_helper< unit<Dim,System> >::type
operator-(const unit<Dim,System>&)
-{
+{
typedef typename unary_minus_typeof_helper< unit<Dim,System> >::type type;
-
+
return type();
}
@@ -353,11 +357,11 @@
operator+(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
BOOST_STATIC_ASSERT((boost::is_same<System1,System2>::value == true));
-
+
typedef System1 system_type;
typedef typename add_typeof_helper< unit<Dim1,system_type>,
unit<Dim2,system_type> >::type type;
-
+
return type();
}
@@ -371,11 +375,11 @@
operator-(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
BOOST_STATIC_ASSERT((boost::is_same<System1,System2>::value == true));
-
+
typedef System1 system_type;
typedef typename subtract_typeof_helper< unit<Dim1,system_type>,
unit<Dim2,system_type> >::type type;
-
+
return type();
}
@@ -390,7 +394,7 @@
{
typedef typename multiply_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type type;
-
+
return type();
}
@@ -405,7 +409,7 @@
{
typedef typename divide_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type type;
-
+
return type();
}
@@ -415,7 +419,7 @@
class System1,
class System2>
inline
-bool
+bool
operator==(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
return boost::is_same<typename reduce_unit<unit<Dim1,System1> >::type, typename reduce_unit<unit<Dim2,System2> >::type>::value;
@@ -427,7 +431,7 @@
class System1,
class System2>
inline
-bool
+bool
operator!=(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
return !boost::is_same<typename reduce_unit<unit<Dim1,System1> >::type, typename reduce_unit<unit<Dim2,System2> >::type>::value;
Modified: branches/units/autoprefix/boost/units/units_fwd.hpp
==============================================================================
--- branches/units/autoprefix/boost/units/units_fwd.hpp (original)
+++ branches/units/autoprefix/boost/units/units_fwd.hpp 2010-03-16 14:38:51 EDT (Tue, 16 Mar 2010)
@@ -1,4 +1,4 @@
-// Boost.Units - A C++ library for zero-overhead dimensional analysis and
+// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
@@ -11,16 +11,22 @@
#ifndef BOOST_UNITS_UNITS_FWD_HPP
#define BOOST_UNITS_UNITS_FWD_HPP
+///
/// \file
-/// Forward declarations of library components.
+/// \brief Forward declarations of library components.
+/// \details Forward declarations of units library - dimensions, systems, quantity and string components.
+/// \author Steven Watanabe
+///
#ifndef BOOST_UNITS_DOXYGEN
#include <string>
-namespace boost {
+namespace boost
+{ //! \namespace boost \brief www.Boost.org.
-namespace units {
+namespace units
+{ //! \namespace boost::units \brief Boost.Units library.
template<typename T,typename V> struct dim;
template<typename T> struct is_dim;
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk