Subject: [Boost-commit] svn:boost r50236 - in branches/release: boost/units boost/units/base_units/temperature boost/units/detail libs/units/doc libs/units/example libs/units/test libs/units/test_headers
From: steven_at_[hidden]
Date: 2008-12-10 22:09:10
Author: steven_watanabe
Date: 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
New Revision: 50236
URL: http://svn.boost.org/trac/boost/changeset/50236
Log:
Merge compiler workarounds, construction from a literal 0, and use of a couple Boost.Math functions from trunk
Added:
branches/release/libs/units/test/test_reduce_unit.cpp
- copied unchanged from r50235, /trunk/libs/units/test/test_reduce_unit.cpp
branches/release/libs/units/test/test_unscale.cpp
- copied unchanged from r50235, /trunk/libs/units/test/test_unscale.cpp
Text files modified:
branches/release/boost/units/base_dimension.hpp | 6
branches/release/boost/units/base_unit.hpp | 6
branches/release/boost/units/base_units/temperature/conversions.hpp | 2
branches/release/boost/units/cmath.hpp | 13 +--
branches/release/boost/units/config.hpp | 20 ++--
branches/release/boost/units/detail/conversion_impl.hpp | 16 ++-
branches/release/boost/units/detail/dimensionless_unit.hpp | 51 +++++++------
branches/release/boost/units/detail/linear_algebra.hpp | 14 ---
branches/release/boost/units/detail/one.hpp | 14 ++
branches/release/boost/units/detail/prevent_redefinition.hpp | 6
branches/release/boost/units/detail/static_rational_power.hpp | 14 ++-
branches/release/boost/units/detail/unscale.hpp | 5
branches/release/boost/units/detail/utility.hpp | 11 --
branches/release/boost/units/homogeneous_system.hpp | 2
branches/release/boost/units/lambda.hpp | 45 +++++++++++
branches/release/boost/units/pow.hpp | 11 ++
branches/release/boost/units/quantity.hpp | 10 ++
branches/release/boost/units/scale.hpp | 6
branches/release/boost/units/static_rational.hpp | 154 ++++++++++++++++++++++++++++++++++++++-
branches/release/libs/units/doc/Jamfile.v2 | 112 ++++++++++++++++++----------
branches/release/libs/units/example/Jamfile.v2 | 25 ++----
branches/release/libs/units/test/Jamfile.v2 | 103 +++++++++++--------------
branches/release/libs/units/test/test_cmath.cpp | 5 -
branches/release/libs/units/test/test_conversion.cpp | 32 ++++---
branches/release/libs/units/test/test_lambda.cpp | 12 +++
branches/release/libs/units/test_headers/Jamfile.v2 | 48 ++++++------
26 files changed, 483 insertions(+), 260 deletions(-)
Modified: branches/release/boost/units/base_dimension.hpp
==============================================================================
--- branches/release/boost/units/base_dimension.hpp (original)
+++ branches/release/boost/units/base_dimension.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -50,7 +50,7 @@
/// to use the same value in multiple definitions.
template<class Derived,
long N
-#ifndef BOOST_UNITS_DOXYGEN
+#if !defined(BOOST_UNITS_DOXYGEN) && !defined(__BORLANDC__)
,
class = typename detail::ordinal_has_already_been_defined<
check_base_dimension<Derived, N>::value
@@ -77,13 +77,13 @@
/// INTERNAL ONLY
friend detail::yes
boost_units_is_registered(const units::base_dimension_ordinal<N>&)
- { return(detail::yes()); }
+ { 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>&)
- { return(detail::yes()); }
+ { detail::yes result; return(result); }
};
} // namespace units
Modified: branches/release/boost/units/base_unit.hpp
==============================================================================
--- branches/release/boost/units/base_unit.hpp (original)
+++ branches/release/boost/units/base_unit.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -53,7 +53,7 @@
template<class Derived,
class Dim,
long N
-#ifndef BOOST_UNITS_DOXYGEN
+#if !defined(BOOST_UNITS_DOXYGEN) && !defined(__BORLANDC__)
,
class = typename detail::ordinal_has_already_been_defined<
check_base_unit<Derived, N>::value
@@ -98,13 +98,13 @@
/// INTERNAL ONLY
friend detail::yes
boost_units_unit_is_registered(const units::base_unit_ordinal<N>&)
- { return(detail::yes()); }
+ { 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>&)
- { return(detail::yes()); }
+ { detail::yes result; return(result); }
};
} // namespace units
Modified: branches/release/boost/units/base_units/temperature/conversions.hpp
==============================================================================
--- branches/release/boost/units/base_units/temperature/conversions.hpp (original)
+++ branches/release/boost/units/base_units/temperature/conversions.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -18,7 +18,7 @@
#define BOOST_UNITS_SYSTEMS_KELVIN_TO_CELSIUS_CONVERSION_DEFINED
#include <boost/units/conversion.hpp>
#include <boost/units/absolute.hpp>
- BOOST_UNITS_DEFINE_CONVERSION_FACTOR(boost::units::si::kelvin_base_unit, boost::units::temperature::celsius_base_unit, one, one());
+ BOOST_UNITS_DEFINE_CONVERSION_FACTOR(boost::units::si::kelvin_base_unit, boost::units::temperature::celsius_base_unit, one, make_one());
BOOST_UNITS_DEFINE_CONVERSION_OFFSET(boost::units::si::kelvin_base_unit, boost::units::temperature::celsius_base_unit, double, -273.15);
#endif
Modified: branches/release/boost/units/cmath.hpp
==============================================================================
--- branches/release/boost/units/cmath.hpp (original)
+++ branches/release/boost/units/cmath.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -24,8 +24,8 @@
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/math/special_functions/hypot.hpp>
-//#include <boost/math/special_functions/next.hpp>
-//#include <boost/math/special_functions/round.hpp>
+#include <boost/math/special_functions/next.hpp>
+#include <boost/math/special_functions/round.hpp>
#include <boost/math/special_functions/sign.hpp>
#include <boost/units/dimensionless_quantity.hpp>
@@ -349,9 +349,6 @@
#endif
-// these are not in the release branch yet
-#if 0
-
template<class Unit,class Y>
inline
quantity<Unit,Y> nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
@@ -378,8 +375,6 @@
return quantity_type::from_value(nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
}
-#endif
-
#if 0
template<class Unit,class Y>
@@ -394,6 +389,8 @@
return quantity_type::from_value(rint BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
+#endif
+
template<class Unit,class Y>
inline
quantity<Unit,Y>
@@ -406,8 +403,6 @@
return quantity_type::from_value(round BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
}
-#endif
-
template<class Unit,class Y>
inline
int
Modified: branches/release/boost/units/config.hpp
==============================================================================
--- branches/release/boost/units/config.hpp (original)
+++ branches/release/boost/units/config.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -14,17 +14,15 @@
#include <boost/config.hpp>
#include <boost/version.hpp>
-#if (BOOST_VERSION >= 103400)
- ///INTERNAL ONLY
- #define BOOST_UNITS_HAS_BOOST_TYPEOF 1
-#else
- ///INTERNAL ONLY
- #define BOOST_UNITS_HAS_BOOST_TYPEOF 0
-#endif
-
-// uncomment this to test without Boost Typeof
-//#undef BOOST_UNITS_HAS_BOOST_TYPEOF
-//#define BOOST_UNITS_HAS_BOOST_TYPEOF 0
+#ifndef BOOST_UNITS_HAS_BOOST_TYPEOF
+ #if (BOOST_VERSION >= 103400)
+ ///INTERNAL ONLY
+ #define BOOST_UNITS_HAS_BOOST_TYPEOF 1
+ #else
+ ///INTERNAL ONLY
+ #define BOOST_UNITS_HAS_BOOST_TYPEOF 0
+ #endif
+#endif
#if (BOOST_UNITS_HAS_BOOST_TYPEOF)
#include <boost/typeof/typeof.hpp>
Modified: branches/release/boost/units/detail/conversion_impl.hpp
==============================================================================
--- branches/release/boost/units/detail/conversion_impl.hpp (original)
+++ branches/release/boost/units/detail/conversion_impl.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -113,7 +113,8 @@
static const bool is_defined = true;
typedef one type;
static type value() {
- return(one());
+ one result;
+ return(result);
}
};
@@ -172,7 +173,8 @@
typedef do_call_base_unit_converter<Dest, typename Source::unit_type> converter;
typedef typename divide_typeof_helper<one, typename converter::type>::type type;
static type value() {
- return(one() / converter::value());
+ one numerator;
+ return(numerator / converter::value());
}
};
};
@@ -232,8 +234,9 @@
{
typedef unit<dimensionless_type, heterogeneous_system<heterogeneous_system_impl<dimensionless_type, dimensionless_type, no_scale> > > unit_type;
typedef one type;
- static type value() {
- return(type());
+ static one value() {
+ one result;
+ return(result);
}
};
};
@@ -322,7 +325,7 @@
struct apply
{
typedef one type;
- static type value() { return(one()); }
+ static type value() { one result; return(result); }
};
};
@@ -482,7 +485,8 @@
typedef typename multiply_typeof_helper<typename impl::type, typename scale::type>::type type;
static type value()
{
- return(one() / (impl::value() * scale::value()));
+ one numerator;
+ return(numerator / (impl::value() * scale::value()));
}
};
Modified: branches/release/boost/units/detail/dimensionless_unit.hpp
==============================================================================
--- branches/release/boost/units/detail/dimensionless_unit.hpp (original)
+++ branches/release/boost/units/detail/dimensionless_unit.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -11,7 +11,6 @@
#ifndef BOOST_UNITS_DETAIL_DIMENSIONLESS_UNIT_HPP
#define BOOST_UNITS_DETAIL_DIMENSIONLESS_UNIT_HPP
-#include <boost/utility/enable_if.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/units/units_fwd.hpp>
@@ -29,14 +28,18 @@
namespace detail {
-template<class T>
-struct is_dimensionless_system : boost::mpl::false_ {};
+template<class System>
+struct void_if_dimensionless {
+ typedef int type;
+};
template<class T>
-struct is_dimensionless_system<boost::units::homogeneous_system<T> > : boost::mpl::true_ {};
+struct void_if_dimensionless<boost::units::homogeneous_system<T> > {
+ typedef void type;
+};
template<>
-struct is_dimensionless_system<
+struct void_if_dimensionless<
boost::units::heterogeneous_system<
boost::units::heterogeneous_system_impl<
boost::units::dimensionless_type,
@@ -44,40 +47,40 @@
boost::units::dimensionless_type
>
>
-> : boost::mpl::true_ {};
+> {
+ typedef void type;
+};
+
+template<class System, class Test = void>
+struct void_if_heterogeneous {
+ typedef void type;
+};
+
+template<class System>
+struct void_if_heterogeneous<System, typename void_if_dimensionless<System>::type> {
+ typedef int type;
+};
-#ifdef BOOST_MSVC
+template<class System, class Enable=void>
+struct is_dimensionless_system : mpl::false_ {};
-#define BOOST_UNITS_DIMENSIONLESS_UNIT(T)\
- boost::units::unit<\
- typename boost::enable_if<boost::units::detail::is_dimensionless_system<T>, boost::units::dimensionless_type>::type,\
- T\
- >
-
-#define BOOST_UNITS_HETEROGENEOUS_DIMENSIONLESS_UNIT(T)\
- boost::units::unit<\
- typename boost::disable_if<boost::units::detail::is_dimensionless_system<T>, boost::units::dimensionless_type>::type,\
- T\
- >
-
-#else
+template<class System>
+struct is_dimensionless_system<System, typename void_if_dimensionless<System>::type> : mpl::true_ {};
#define BOOST_UNITS_DIMENSIONLESS_UNIT(T)\
boost::units::unit<\
boost::units::dimensionless_type,\
T,\
- typename boost::enable_if<boost::units::detail::is_dimensionless_system<T> >::type\
+ typename ::boost::units::detail::void_if_dimensionless<T>::type\
>
#define BOOST_UNITS_HETEROGENEOUS_DIMENSIONLESS_UNIT(T)\
boost::units::unit<\
boost::units::dimensionless_type,\
T,\
- typename boost::disable_if<boost::units::detail::is_dimensionless_system<T> >::type\
+ typename ::boost::units::detail::void_if_heterogeneous<T>::type\
>
-#endif
-
}
}
}
Modified: branches/release/boost/units/detail/linear_algebra.hpp
==============================================================================
--- branches/release/boost/units/detail/linear_algebra.hpp (original)
+++ branches/release/boost/units/detail/linear_algebra.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -952,20 +952,6 @@
// dimension.
//
// list<rational> calculate_base_unit_exponents(list<base_unit> units, dimension_list dimensions);
-//
-// What is the purpose of all this magic with
-// base_dimensions? Can't we just solve the
-// equations for the dimension directly? Yes,
-// we can, but remember that solving a
-// system of linear equations is O(N^3).
-// By normalizing the system we incur a
-// high one time cost O(N^4), but for all
-// solutions after the first it is O(N^2)
-// In addition, the constant factor is
-// good because everything is already set up.
-// Since we expect a few systems to be
-// used many times, the cost of creating
-// a system is probably not significant.
template<class T>
struct is_base_dimension_unit {
Modified: branches/release/boost/units/detail/one.hpp
==============================================================================
--- branches/release/boost/units/detail/one.hpp (original)
+++ branches/release/boost/units/detail/one.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -17,7 +17,13 @@
namespace units {
-struct one { };
+struct one { one() {} };
+
+// workaround for pathscale.
+inline one make_one() {
+ one result;
+ return(result);
+}
template<class T>
struct multiply_typeof_helper<one, T>
@@ -51,7 +57,8 @@
inline one operator*(const one&, const one&)
{
- return(one());
+ one result;
+ return(result);
}
template<class T>
@@ -86,7 +93,8 @@
inline one operator/(const one&, const one&)
{
- return(one());
+ one result;
+ return(result);
}
} // namespace units
Modified: branches/release/boost/units/detail/prevent_redefinition.hpp
==============================================================================
--- branches/release/boost/units/detail/prevent_redefinition.hpp (original)
+++ branches/release/boost/units/detail/prevent_redefinition.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -19,7 +19,7 @@
namespace detail {
-typedef char no;
+struct no { no() {} char dummy; };
struct yes { no dummy[2]; };
template<bool> struct ordinal_has_already_been_defined;
@@ -39,13 +39,13 @@
template<class T>
detail::no
boost_units_is_registered(const T&)
-{ return(detail::no()); }
+{ detail::no result; return(result); }
/// INTERNAL ONLY
template<class T>
detail::no
boost_units_unit_is_registered(const T&)
-{ return(detail::no()); }
+{ detail::no result; return(result); }
} // namespace units
Modified: branches/release/boost/units/detail/static_rational_power.hpp
==============================================================================
--- branches/release/boost/units/detail/static_rational_power.hpp (original)
+++ branches/release/boost/units/detail/static_rational_power.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -2,7 +2,7 @@
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
-// Copyright (C) 2008 Steven Watanabe
+// Copyright (C) 2007-2008 Steven Watanabe
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
@@ -63,7 +63,8 @@
typedef one type;
static one call(const one&)
{
- return(one());
+ one result;
+ return(result);
}
};
@@ -73,7 +74,8 @@
typedef one type;
static one call(const one&)
{
- return(one());
+ one result;
+ return(result);
}
};
@@ -156,7 +158,8 @@
typedef typename impl::type type;
static type call(const Y& y)
{
- return(impl::call(y, one()));
+ one result;
+ return(impl::call(y, result));
}
};
};
@@ -171,7 +174,8 @@
typedef typename divide_typeof_helper<one, typename impl::type>::type type;
static type call(const Y& y)
{
- return(one()/impl::call(y, one()));
+ one result;
+ return(result/impl::call(y, result));
}
};
};
Modified: branches/release/boost/units/detail/unscale.hpp
==============================================================================
--- branches/release/boost/units/detail/unscale.hpp (original)
+++ branches/release/boost/units/detail/unscale.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -157,9 +157,10 @@
struct apply
{
typedef one type;
- static type value()
+ static one value()
{
- return(type());
+ one result;
+ return(result);
}
};
};
Modified: branches/release/boost/units/detail/utility.hpp
==============================================================================
--- branches/release/boost/units/detail/utility.hpp (original)
+++ branches/release/boost/units/detail/utility.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -21,16 +21,13 @@
#include <boost/cstdint.hpp>
#include <boost/limits.hpp>
-#if (__GNUC__ && __cplusplus && __GNUC__ >= 3)
+#if defined(__GLIBCXX__) || defined(__GLIBCPP__)
#define BOOST_UNITS_USE_DEMANGLING
+#include <cxxabi.h>
#endif // __GNUC__
#ifdef BOOST_UNITS_USE_DEMANGLING
-#if (__GNUC__ && __cplusplus && __GNUC__ >= 3)
-#include <cxxabi.h>
-#endif // __GNUC__
-
#include <boost/algorithm/string/replace.hpp>
namespace boost {
@@ -43,7 +40,6 @@
std::string
demangle(const char* name)
{
- #if (__GNUC__ && __cplusplus && __GNUC__ >= 3)
// need to demangle C++ symbols
char* realname;
std::size_t len;
@@ -69,9 +65,6 @@
}
return std::string("demangle :: error - unable to demangle specified symbol");
- #else
- return name;
- #endif
}
} // namespace detail
Modified: branches/release/boost/units/homogeneous_system.hpp
==============================================================================
--- branches/release/boost/units/homogeneous_system.hpp (original)
+++ branches/release/boost/units/homogeneous_system.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -18,7 +18,7 @@
#ifdef BOOST_UNITS_CHECK_HOMOGENEOUS_UNITS
-#include <boost/is_same.hpp>
+#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/not.hpp>
#include <boost/units/detail/linear_algebra.hpp>
Modified: branches/release/boost/units/lambda.hpp
==============================================================================
--- branches/release/boost/units/lambda.hpp (original)
+++ branches/release/boost/units/lambda.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -34,6 +34,7 @@
#include <boost/lambda/lambda.hpp>
#include <boost/units/units_fwd.hpp>
+#include <boost/units/detail/dimensionless_unit.hpp>
#include <boost/units/operators.hpp>
namespace boost {
@@ -318,6 +319,28 @@
};
/// Partial specialization of return type trait for action
+ /// quantity<dimensionless, X> + Y.
+ template<typename System, typename X, typename Y>
+ struct plain_return_type_2<arithmetic_action<plus_action>,
+ boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
+ Y> {
+ typedef typename boost::units::add_typeof_helper<
+ boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
+ Y>::type type;
+ };
+
+ /// Partial specialization of return type trait for action
+ /// X + quantity<dimensionless, Y>.
+ template<typename System, typename X, typename Y>
+ struct plain_return_type_2<arithmetic_action<plus_action>,
+ X,
+ boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
+ typedef typename boost::units::add_typeof_helper<
+ X,
+ boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
+ };
+
+ /// Partial specialization of return type trait for action
/// quantity<Unit1, X> - quantity<Unit2, Y>.
template<typename Unit1, typename X, typename Unit2, typename Y>
struct plain_return_type_2<arithmetic_action<minus_action>,
@@ -329,6 +352,28 @@
};
/// Partial specialization of return type trait for action
+ /// quantity<dimensionless, X> - Y.
+ template<typename System, typename X, typename Y>
+ struct plain_return_type_2<arithmetic_action<minus_action>,
+ boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
+ Y> {
+ typedef typename boost::units::subtract_typeof_helper<
+ boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
+ Y>::type type;
+ };
+
+ /// Partial specialization of return type trait for action
+ /// X - quantity<dimensionless, Y>.
+ template<typename System, typename X, typename Y>
+ struct plain_return_type_2<arithmetic_action<minus_action>,
+ X,
+ boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
+ typedef typename boost::units::subtract_typeof_helper<
+ X,
+ boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
+ };
+
+ /// Partial specialization of return type trait for action
/// quantity<Unit1, X> * quantity<Unit2, Y>.
template<typename Unit1, typename X, typename Unit2, typename Y>
struct plain_return_type_2<arithmetic_action<multiply_action>,
Modified: branches/release/boost/units/pow.hpp
==============================================================================
--- branches/release/boost/units/pow.hpp (original)
+++ branches/release/boost/units/pow.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -60,7 +60,10 @@
/// raise @c float to a @c static_rational power
template<long N,long D>
struct power_typeof_helper<float, static_rational<N,D> >
- : power_typeof_helper<double, static_rational<N,D> > {};
+ : power_typeof_helper<double, static_rational<N,D> > {
+ typedef typename power_typeof_helper<double, static_rational<N,D> >::type type;
+ using power_typeof_helper<double, static_rational<N,D> >::value;
+};
#endif
@@ -85,7 +88,11 @@
/// take @c static_rational root of an @c T
template<class T, long N,long D>
struct root_typeof_helper<T,static_rational<N,D> >
- : power_typeof_helper<T, static_rational<D,N> > {};
+ : power_typeof_helper<T, static_rational<D,N> > {
+ // help pathscale?
+ typedef typename power_typeof_helper<T, static_rational<D,N> >::type type;
+ using power_typeof_helper<T, static_rational<D,N> >::value;
+};
#endif
Modified: branches/release/boost/units/quantity.hpp
==============================================================================
--- branches/release/boost/units/quantity.hpp (original)
+++ branches/release/boost/units/quantity.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -91,6 +91,7 @@
// 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;
@@ -101,6 +102,11 @@
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
+
+ quantity(unspecified_null_pointer_constant_type) : val_()
+ {
+ BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
+ }
quantity(const this_type& source) : val_(source.val_)
{
@@ -275,10 +281,10 @@
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); }
+ static this_type from_value(const value_type& val) { return this_type(val, 0); }
protected:
- explicit quantity(const value_type& val) : val_(val) { }
+ explicit quantity(const value_type& val, int) : val_(val) { }
private:
value_type val_;
Modified: branches/release/boost/units/scale.hpp
==============================================================================
--- branches/release/boost/units/scale.hpp (original)
+++ branches/release/boost/units/scale.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -49,9 +49,9 @@
static const long base = Base;
typedef static_rational<0> exponent;
typedef one value_type;
- static one value() { return(one()); }
- static std::string name() { return(std::string()); }
- static std::string symbol() { return(std::string()); }
+ static one value() { one result; return(result); }
+ static std::string name() { return(""); }
+ static std::string symbol() { return(""); }
};
template<long Base>
Modified: branches/release/boost/units/static_rational.hpp
==============================================================================
--- branches/release/boost/units/static_rational.hpp (original)
+++ branches/release/boost/units/static_rational.hpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -15,6 +15,12 @@
#include <boost/mpl/less.hpp>
#include <boost/mpl/arithmetic.hpp>
+#ifdef __BORLANDC__
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/identity.hpp>
+#endif
+
#include <boost/units/config.hpp>
#include <boost/units/operators.hpp>
@@ -37,7 +43,7 @@
template<integer_type Value>
struct static_abs
{
- BOOST_STATIC_CONSTANT(integer_type,value) = Value < 0 ? -Value : Value;
+ BOOST_STATIC_CONSTANT(integer_type,value = Value < 0 ? -Value : Value);
};
/// Compile time rational number.
@@ -59,10 +65,68 @@
may not be floating point values, while powers and roots of rational numbers can produce floating point
values.
*/
+#ifdef __BORLANDC__
+
+template<integer_type X>
+struct make_integral_c {
+ typedef boost::mpl::integral_c<integer_type, X> type;
+};
+
+template<integer_type N,integer_type D = 1>
+class static_rational
+{
+ public:
+
+ typedef static_rational this_type;
+
+ typedef boost::mpl::integral_c<integer_type, N> N_type;
+ typedef boost::mpl::integral_c<integer_type, D> D_type;
+
+ typedef typename make_integral_c<
+ (::boost::math::static_gcd<
+ ::boost::units::static_abs<N>::value,
+ ::boost::units::static_abs<D>::value
+ >::value)>::type gcd_type;
+ typedef typename boost::mpl::eval_if<
+ boost::mpl::less<
+ D_type,
+ boost::mpl::integral_c<integer_type, 0>
+ >,
+ boost::mpl::negate<gcd_type>,
+ gcd_type
+ >::type den_type;
+
+ public:
+ // for mpl arithmetic support
+ typedef detail::static_rational_tag tag;
+
+ BOOST_STATIC_CONSTANT(integer_type, Numerator =
+ (::boost::mpl::divides<N_type, den_type>::value));
+ BOOST_STATIC_CONSTANT(integer_type, Denominator =
+ (::boost::mpl::divides<D_type, den_type>::value));
+
+ /// INTERNAL ONLY
+ typedef static_rational<N,D> this_type;
+
+ /// static_rational<N,D> reduced by GCD
+ typedef static_rational<
+ (::boost::mpl::divides<N_type, den_type>::value),
+ (::boost::mpl::divides<D_type, den_type>::value)
+ > type;
+
+ static integer_type numerator() { return Numerator; }
+ static integer_type denominator() { return Denominator; }
+
+ // INTERNAL ONLY
+ static_rational() { }
+ //~static_rational() { }
+};
+#else
template<integer_type N,integer_type D = 1>
class static_rational
{
private:
+
static const integer_type nabs = static_abs<N>::value,
dabs = static_abs<D>::value;
@@ -76,7 +140,7 @@
typedef detail::static_rational_tag tag;
static const integer_type Numerator = N/den,
- Denominator = D/den;
+ Denominator = D/den;
/// INTERNAL ONLY
typedef static_rational<N,D> this_type;
@@ -89,9 +153,9 @@
// INTERNAL ONLY
static_rational() { }
- //~static_rational() { }
-
+ //~static_rational() { }
};
+#endif
}
@@ -126,6 +190,86 @@
namespace mpl {
+#ifdef __BORLANDC__
+
+template<>
+struct plus_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag>
+{
+ template<class T0, class T1>
+ struct apply {
+ typedef typename boost::units::static_rational<
+ ::boost::mpl::plus<
+ boost::mpl::times<typename T0::N_type, typename T1::D_type>,
+ boost::mpl::times<typename T1::N_type, typename T0::D_type>
+ >::value,
+ ::boost::mpl::times<typename T0::D_type, typename T1::D_type>::value
+ >::type type;
+ };
+};
+
+template<>
+struct minus_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag>
+{
+ template<class T0, class T1>
+ struct apply {
+ typedef typename boost::units::static_rational<
+ ::boost::mpl::minus<
+ boost::mpl::times<typename T0::N_type, typename T1::D_type>,
+ boost::mpl::times<typename T1::N_type, typename T0::D_type>
+ >::value,
+ ::boost::mpl::times<typename T0::D_type, typename T1::D_type>::value
+ >::type type;
+ };
+};
+
+template<>
+struct times_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag>
+{
+ template<class T0, class T1>
+ struct apply {
+ typedef typename boost::units::static_rational<
+ ::boost::mpl::times<typename T0::N_type, typename T1::N_type>::value,
+ ::boost::mpl::times<typename T0::D_type, typename T1::D_type>::value
+ >::type type;
+ };
+};
+
+template<>
+struct divides_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag>
+{
+ template<class T0, class T1>
+ struct apply {
+ typedef typename boost::units::static_rational<
+ ::boost::mpl::times<typename T0::N_type, typename T1::D_type>::value,
+ ::boost::mpl::times<typename T0::D_type, typename T1::N_type>::value
+ >::type type;
+ };
+};
+
+template<>
+struct negate_impl<boost::units::detail::static_rational_tag>
+{
+ template<class T0>
+ struct apply {
+ typedef typename boost::units::static_rational<
+ ::boost::mpl::negate<typename T0::N_type>::value,
+ ::boost::mpl::identity<T0>::type::Denominator
+ >::type type;
+ };
+};
+
+template<>
+struct less_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag>
+{
+ template<class T0, class T1>
+ struct apply
+ {
+ typedef mpl::bool_<((mpl::minus<T0, T1>::type::Numerator) < 0)> type;
+ };
+};
+
+#else
+
template<>
struct plus_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag>
{
@@ -193,6 +337,8 @@
};
};
+#endif
+
}
Modified: branches/release/libs/units/doc/Jamfile.v2
==============================================================================
--- branches/release/libs/units/doc/Jamfile.v2 (original)
+++ branches/release/libs/units/doc/Jamfile.v2 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -17,31 +17,30 @@
path-constant here : . ;
-rule run_doxygen ( target : files * : name : expand ? )
+rule run_doxygen ( target : files * : name )
{
-
- expand ?= <doxygen:param>EXPAND_ONLY_PREDEF=YES ;
-
-doxygen $(target)
- :
- $(files)
- :
+ doxygen $(target)
+ :
+ $(files)
+ :
<doxygen:param>EXTRACT_ALL=YES
+ <doxygen:param>EXPAND_ONLY_PREDEF=YES
-# Horribly ugly, but then macros usually are :(
- <doxygen:param>"PREDEFINED=\"BOOST_UNITS_STATIC_CONSTANT(a,b)=static const b a\" \\
- \"BOOST_UNITS_AUTO_STATIC_CONSTANT(a,b)=static const auto a = b\" \\
- \"BOOST_UNITS_TYPEOF(a)=typeof(a)\" \\
- \"BOOST_PREVENT_MACRO_SUBSTITUTION=\" \\
- \"BOOST_UNITS_HAS_TYPEOF=1\" \\
- \"BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(namespace_, name_, name_string, symbol_, factor, other_unit, id)= \\
- namespace boost { namespace units { namespace namespace_ { \\
- struct name_ ## _base_unit : boost::units::base_unit<name_ ## _base_unit, other_unit::dimension_type, id> { \\
- static const char* name(); \\
- static const char* symbol(); \\
- }; \\
- } } }\" \\
- \"BOOST_UNITS_DOXYGEN=1\""
+ # Horribly ugly, but then macros usually are :(
+ <doxygen:param>"PREDEFINED= \\
+ \"BOOST_UNITS_STATIC_CONSTANT(a,b)=static const b a\" \\
+ \"BOOST_UNITS_AUTO_STATIC_CONSTANT(a,b)=static const auto a = b\" \\
+ \"BOOST_UNITS_TYPEOF(a)=typeof(a)\" \\
+ \"BOOST_PREVENT_MACRO_SUBSTITUTION=\" \\
+ \"BOOST_UNITS_HAS_TYPEOF=1\" \\
+ \"BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(namespace_, name_, name_string, symbol_, factor, other_unit, id)= \\
+ namespace boost { namespace units { namespace namespace_ { \\
+ struct name_ ## _base_unit : boost::units::base_unit<name_ ## _base_unit, other_unit::dimension_type, id> { \\
+ static const char* name(); \\
+ static const char* symbol(); \\
+ }; \\
+ } } }\" \\
+ \"BOOST_UNITS_DOXYGEN=1\""
<doxygen:param>HIDE_UNDOC_MEMBERS=NO
<doxygen:param>EXTRACT_PRIVATE=NO
<doxygen:param>ENABLE_PREPROCESSING=YES
@@ -49,7 +48,7 @@
$(expand)
<doxygen:param>SEARCH_INCLUDES=NO
<reftitle>$(name)
- ;
+ ;
}
@@ -76,7 +75,8 @@
"CGS System Reference"
;
-rule make_base_units_doc ( directory : name ) {
+rule make_base_units_doc ( directory : name )
+{
run_doxygen $(directory)_base_units_reference
:
[ path.glob-tree $(here)/../../../boost/units/base_units/$(directory) : *.hpp : detail conversions.hpp ]
@@ -127,39 +127,48 @@
"Abstract System Reference"
;
-rule less ( a b ) {
- if [ path.basename $(a) ] < [ path.basename $(b) ] {
+rule less ( a b )
+{
+ if [ path.basename $(a) ] < [ path.basename $(b) ]
+ {
return true ;
}
}
-rule generate-qbk ( target : sources * : properties * ) {
+rule generate-qbk ( target : sources * : properties * )
+{
print.output $(target) ;
local as-path = [ sequence.transform path.make : $(sources:G=) ] ;
local known = ;
local duplicated = ;
- for local file in $(as-path) {
+ for local file in $(as-path)
+ {
local base = [ path.basename $(file) ] ;
- if $(base) in $(known) {
- if ! $(base) in $(duplicated) {
+ if $(base) in $(known)
+ {
+ if ! $(base) in $(duplicated)
+ {
duplicated += $(base) ;
}
- } else {
+ } else
+ {
known += $(base) ;
}
}
- for local file in [ sequence.insertion-sort $(as-path) : less ] {
+ for local file in [ sequence.insertion-sort $(as-path) : less ]
+ {
local output_filename = [ path.relative-to [ path.make $(here)/../../.. ] $(file) ] ;
local base_filename = [ path.basename $(file) ] ;
local base_unit = [ regex.replace $(base_filename) "\\.hpp" "" ] ;
- if $(base_filename) in $(duplicated) {
+ if $(base_filename) in $(duplicated)
+ {
# tack the directory name onto the end
local dir-name = [ path.basename [ path.parent $(file) ] ] ;
base_unit = "$(base_unit) ($(dir-name))" ;
}
-# this looks better, but it won't work until my boostbook patch for
-# annotation.xsl gets applied.
-# print.text "[headerref $(output_filename) $(base_unit)]\\n" : overwrite ;
+ # this looks better, but it won't work until my boostbook patch for
+ # annotation.xsl gets applied.
+ # print.text "[headerref $(output_filename) $(base_unit)]\\n" : overwrite ;
print.text "[headerref $(output_filename)]\\n" : overwrite ;
}
}
@@ -184,6 +193,8 @@
<dependency>abstract_reference
;
+path-constant images_location : ../../../doc/html ;
+
boostbook standalone
:
units
@@ -191,8 +202,31 @@
<xsl:param>toc.max.depth=1
<xsl:param>toc.section.depth=8
<xsl:param>chunk.section.depth=8
- <xsl:param>fop1.extensions=1
- <xsl:param>fop.extensions=0
<xsl:param>boost.root="../../../.."
<xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
- ;
+
+ # PDF Options:
+ # TOC generation: uses XEP extensions at present, change to fop1 to use Apache FOP.
+ <format>pdf:<xsl:param>xep.extensions=1
+ <format>pdf:<xsl:param>fop.extensions=0
+ <format>pdf:<xsl:param>fop1.extensions=0
+ # No indent on body text:
+ <format>pdf:<xsl:param>body.start.indent=0pt
+ # Margin size:
+ <format>pdf:<xsl:param>page.margin.inner=0.5in
+ # Margin size:
+ <format>pdf:<xsl:param>page.margin.outer=0.5in
+ # Paper type = A4
+ <format>pdf:<xsl:param>paper.type=A4
+ # Yes, we want graphics for admonishments:
+ <xsl:param>admon.graphics=1
+ # Set this one for PDF generation *only*:
+ # default pnd graphics are awful in PDF form,
+ # better use SVG's instead:
+ <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+ <format>pdf:<xsl:param>img.src.path=$(images_location)/
+ <format>pdf:<xsl:param>admon.graphics.path=../../../doc/src/images
+ <format>pdf:<xsl:param>draft.mode="no"
+;
+
+
Modified: branches/release/libs/units/example/Jamfile.v2
==============================================================================
--- branches/release/libs/units/example/Jamfile.v2 (original)
+++ branches/release/libs/units/example/Jamfile.v2 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -1,32 +1,25 @@
# Jamfile.v2
#
-# Copyright (c) 2007
+# Copyright (c) 2007-2008
# Steven Watanabe
#
# Distributed under the Boost Software License, Version 1.0. (See
-# accomanying file LICENSE_1_0.txt or copy at
+# accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt
import testing ;
import path ;
-project units_examples :
+project boost/units/example :
: requirements <include>$(BOOST_ROOT) <include>../../.. <warnings>all
;
-rule make_tests ( files * ) {
- local results = ;
- for local file in $(files) {
- results += [ run $(file) : : : ] ;
- }
-}
+files = [ path.glob . : *.cpp : performance.* runtime_unit.* ] ;
+for local file in $(files)
{
- test-suite units
- :
- [ make_tests [ path.glob . : *.cpp : performance.* runtime_unit.* ] ]
- [ compile performance.cpp ]
- [ run runtime_unit.cpp : <runtime_unit_input.txt : : ]
- ;
-
+ run $(file) ;
}
+
+compile performance.cpp ;
+run runtime_unit.cpp : <runtime_unit_input.txt ;
Modified: branches/release/libs/units/test/Jamfile.v2
==============================================================================
--- branches/release/libs/units/test/Jamfile.v2 (original)
+++ branches/release/libs/units/test/Jamfile.v2 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -4,69 +4,58 @@
# Steven Watanabe
#
# Distributed under the Boost Software License, Version 1.0. (See
-# accomanying file LICENSE_1_0.txt or copy at
+# accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt
-project units_test :
+project boost/units/test :
requirements <include>$(BOOST_ROOT) <include>../../.. <toolset>msvc:<asynch-exceptions>on
;
-check-conversion-dependencies = [ path.glob-tree ../../../boost/units/systems/base_units : *.hpp ] ;
-checklibs =
- $(BOOST_ROOT)/libs/regex/build//boost_regex
- $(BOOST_ROOT)/libs/filesystem/build//boost_filesystem
- $(BOOST_ROOT)/libs/system/build//boost_system
-;
-
import testing ;
alias test_framework : $(BOOST_ROOT)/libs/test/build//boost_unit_test_framework ;
-#alias test_minimal : $(BOOST_ROOT)/libs/test/build//minimal ;
-
-{
- test-suite units
- :
- [ compile test_predicates.cpp : : ]
- [ compile test_negative_denominator.cpp : : ]
- [ compile test_dimensionless_ice1.cpp : : ]
- [ compile test_dimensionless_ice2.cpp : : ]
- [ compile test_mixed_value_types.cpp : : ]
- [ compile test_complicated_system.cpp : : ]
- [ run test_dimensionless_quantity.cpp : : : : ]
- [ run test_implicit_conversion.cpp : : : : ]
- [ run test_quantity.cpp : : : : ]
- [ run test_unit.cpp : : : : ]
- [ run test_conversion.cpp : : : : ]
- [ run test_base_dimension.cpp : : : : ]
- [ run test_absolute.cpp : : : : ]
- [ run test_default_conversion.cpp : : : : ]
- [ run test_cmath.cpp : : : : ]
- [ run test_limits.cpp : : : : ]
- [ run test_custom_unit.cpp : : : : ]
- [ run test_scaled_conversion.cpp : : : : ]
- [ run test_lambda.cpp : : : : ]
- [ run test_scaled_unit.cpp test_framework : : : : ]
-# [ run check_conversion_defs.cpp $(checklibs) : : : <dependency>$(check-conversion-dependencies) : ]
- [ compile-fail fail_implicit_conversion.cpp : : ]
- [ compile-fail fail_quantity_construct.cpp : : ]
- [ compile-fail fail_quantity_assign.cpp : : ]
- [ compile-fail fail_quantity_add.cpp : : ]
- [ compile-fail fail_quantity_subtract.cpp : : ]
- [ compile-fail fail_quantity_add_assign.cpp : : ]
- [ compile-fail fail_quantity_sub_assign.cpp : : ]
- [ compile-fail fail_quantity_scalar_add.cpp : : ]
- [ compile-fail fail_quantity_scalar_sub.cpp : : ]
- [ compile-fail fail_quantity_unit_add.cpp : : ]
- [ compile-fail fail_quantity_unit_subtract.cpp : : ]
- [ compile-fail fail_scalar_quantity_add.cpp : : ]
- [ compile-fail fail_scalar_quantity_sub.cpp : : ]
- [ compile-fail fail_unit_quantity_add.cpp : : ]
- [ compile-fail fail_unit_quantity_subtract.cpp : : ]
- [ compile-fail fail_adl_detail.cpp : : ]
- [ compile-fail fail_heterogeneous_unit.cpp : : ]
- [ compile-fail fail_base_dimension.cpp : : ]
- [ compile-fail fail_add_temperature.cpp : : ]
- [ compile-fail fail_quantity_non_unit.cpp : : ]
- ;
-}
+compile test_predicates.cpp ;
+compile test_negative_denominator.cpp ;
+compile test_dimensionless_ice1.cpp ;
+compile test_dimensionless_ice2.cpp ;
+compile test_mixed_value_types.cpp ;
+compile test_complicated_system.cpp ;
+compile test_reduce_unit.cpp ;
+compile test_unscale.cpp ;
+
+run test_dimensionless_quantity.cpp ;
+run test_implicit_conversion.cpp ;
+run test_quantity.cpp ;
+run test_unit.cpp ;
+run test_conversion.cpp test_framework ;
+run test_base_dimension.cpp ;
+run test_absolute.cpp ;
+run test_default_conversion.cpp ;
+run test_cmath.cpp ;
+run test_limits.cpp ;
+run test_custom_unit.cpp ;
+run test_scaled_conversion.cpp ;
+run test_lambda.cpp ;
+run test_scaled_unit.cpp test_framework ;
+
+compile-fail fail_implicit_conversion.cpp ;
+compile-fail fail_quantity_construct.cpp ;
+compile-fail fail_quantity_assign.cpp ;
+compile-fail fail_quantity_add.cpp ;
+compile-fail fail_quantity_subtract.cpp ;
+compile-fail fail_quantity_add_assign.cpp ;
+compile-fail fail_quantity_sub_assign.cpp ;
+compile-fail fail_quantity_scalar_add.cpp ;
+compile-fail fail_quantity_scalar_sub.cpp ;
+compile-fail fail_quantity_unit_add.cpp ;
+compile-fail fail_quantity_unit_subtract.cpp ;
+compile-fail fail_scalar_quantity_add.cpp ;
+compile-fail fail_scalar_quantity_sub.cpp ;
+compile-fail fail_unit_quantity_add.cpp ;
+compile-fail fail_unit_quantity_subtract.cpp ;
+compile-fail fail_adl_detail.cpp ;
+compile-fail fail_heterogeneous_unit.cpp ;
+compile-fail fail_base_dimension.cpp ;
+compile-fail fail_add_temperature.cpp ;
+compile-fail fail_quantity_non_unit.cpp ;
Modified: branches/release/libs/units/test/test_cmath.cpp
==============================================================================
--- branches/release/libs/units/test/test_cmath.cpp (original)
+++ branches/release/libs/units/test/test_cmath.cpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -129,19 +129,14 @@
#endif
-#if 0
-
BOOST_CHECK((bu::nextafter)(E4,E5).value() == (boost::math::nextafter)(E4.value(),E5.value()));
BOOST_CHECK((bu::nextafter)(E5,E4).value() == (boost::math::nextafter)(E5.value(),E4.value()));
BOOST_CHECK((bu::nexttoward)(E4,E5).value() == (boost::math::nextafter)(E4.value(),E5.value()));
BOOST_CHECK((bu::nexttoward)(E5,E4).value() == (boost::math::nextafter)(E5.value(),E4.value()));
-
BOOST_CHECK((bu::round)(E4 - 0.00000000001 * bu::joules) == -3.0*bu::joules);
BOOST_CHECK((bu::round)(E5 + 0.00000000001 * bu::joules) == 3.0*bu::joules);
-#endif
-
BOOST_CHECK((bu::signbit)(E4) == 1);
BOOST_CHECK((bu::signbit)(E5) == 0);
BOOST_CHECK((bu::trunc)(E4) == -2.0*bu::joules);
Modified: branches/release/libs/units/test/test_conversion.cpp
==============================================================================
--- branches/release/libs/units/test/test_conversion.cpp (original)
+++ branches/release/libs/units/test/test_conversion.cpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -27,9 +27,11 @@
#include <iostream>
-#include <boost/test/minimal.hpp>
+#define BOOST_TEST_MAIN
-#define BOOST_UNITS_CHECK_CLOSE(a, b) (BOOST_CHECK((std::abs((a) - (b)) < .0000001)))
+#include <boost/test/unit_test.hpp>
+
+#define BOOST_UNITS_CHECK_CLOSE(a, b) BOOST_CHECK_CLOSE_FRACTION(a, b, .0000001)
namespace bu = boost::units;
@@ -50,35 +52,39 @@
typedef bu::divide_typeof_helper<bu::multiply_typeof_helper<cgs_mass,mixed_length>::type,
bu::multiply_typeof_helper<cgs_time,cgs_time>::type >::type mixed_energy_2;
-int test_main(int,char *[])
-{
+BOOST_AUTO_TEST_CASE(test_conversion) {
+ BOOST_CHECK_EQUAL(1, 1);
bu::quantity<mixed_length> a1(2.0 * mixed_length());
bu::quantity<si_area> a2(a1);
- BOOST_CHECK((std::abs(a2.value() - .02) < .0001));
+ BOOST_UNITS_CHECK_CLOSE(a2.value(), .02);
bu::quantity<mixed_length> a3(a2);
- BOOST_CHECK((std::abs(a3.value() - 2.0) < .0001));
+ BOOST_UNITS_CHECK_CLOSE(a3.value(), 2.0);
bu::quantity<mixed_energy_1> e1(2.0 * mixed_energy_1());
bu::quantity<mixed_energy_2> e2(e1);
- BOOST_CHECK((std::abs(e2.value() - 20.0) < .0001));
+ BOOST_UNITS_CHECK_CLOSE(e2.value(), 20.0);
bu::quantity<bu::si::energy> e3(e1);
- BOOST_CHECK((std::abs(e3.value() - .0002) < .0001));
+ BOOST_UNITS_CHECK_CLOSE(e3.value(), .0002);
bu::quantity<mixed_energy_2> e4(e3);
- BOOST_CHECK((std::abs(e4.value() - 20.0) < .0001));
+ BOOST_UNITS_CHECK_CLOSE(e4.value(), 20.0);
bu::quantity<bu::cgs::force> F0 = 20 * bu::cgs::dyne;
- BOOST_CHECK((std::abs(F0.value() - 20.0) < .0001));
+ BOOST_UNITS_CHECK_CLOSE(F0.value(), 20.0);
bu::quantity<bu::si::force> F3(F0);
- BOOST_CHECK((std::abs(F3.value() - 2.0e-4) < .000000001));
+ BOOST_UNITS_CHECK_CLOSE(F3.value(), 2.0e-4);
bu::quantity<bu::si::force> F5(20 * bu::cgs::dyne);
- BOOST_CHECK((std::abs(F5.value() - 2.0e-4) < .000000001));
+ BOOST_UNITS_CHECK_CLOSE(F5.value(), 2.0e-4);
+
+}
+
+BOOST_AUTO_TEST_CASE(test_dimensionless_conversions) {
bu::quantity<bu::si::dimensionless> dimensionless_test1(1.0*bu::cgs::dyne/bu::si::newton);
BOOST_CHECK(dimensionless_test1 == 1e-5);
@@ -94,6 +100,4 @@
bu::quantity<bu::divide_typeof_helper<bu::si::length, bu::cgs::length>::type> dimensionless_test4(2.0 * bu::si::meters / bu::cgs::centimeters);
bu::quantity<bu::divide_typeof_helper<bu::cgs::mass, bu::si::mass>::type> dimensionless_test5(dimensionless_test4);
BOOST_UNITS_CHECK_CLOSE(dimensionless_test5.value(), 2e5);
-
- return(0);
}
Modified: branches/release/libs/units/test/test_lambda.cpp
==============================================================================
--- branches/release/libs/units/test/test_lambda.cpp (original)
+++ branches/release/libs/units/test/test_lambda.cpp 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -142,9 +142,21 @@
// quantity<Unit1, X> + quantity<Unit2, Y>
BOOST_CHECK(((bl::_1 + bl::_2)(2.0 * bu::meter, 4.0 * bu::meter) == 6.0 * bu::meter));
+ // quantity<dimensionless, X> + Y
+ BOOST_CHECK(((bl::_1 + 1.0f)(bu::quantity<bu::dimensionless>(2.0)) == 3.0));
+
+ // X + quantity<dimensionless, Y>
+ BOOST_CHECK(((1.0f + bl::_1)(bu::quantity<bu::dimensionless>(1.0)) == 2.0));
+
// quantity<Unit1, X> - quantity<Unit2, Y>
BOOST_CHECK(((bl::_1 - bl::_2)(2.0 * bu::meter, 4.0 * bu::meter) == -2.0 * bu::meter));
+ // quantity<dimensionless, X> - Y
+ BOOST_CHECK(((bl::_1 - 2.0f)(bu::quantity<bu::dimensionless>(1.0)) == -1.0));
+
+ // X - quantity<dimensionless, Y>
+ BOOST_CHECK(((2.0f - bl::_1)(bu::quantity<bu::dimensionless>(1.0)) == 1.0));
+
// quantity<Unit1, X> * quantity<Unit2, Y>
BOOST_CHECK(((bl::_1 * bl::_2)(2.0 * bu::kilogram, 4.0 * bu::meter_per_second) == 8.0 * bu::kilogram * bu::meter_per_second));
Modified: branches/release/libs/units/test_headers/Jamfile.v2
==============================================================================
--- branches/release/libs/units/test_headers/Jamfile.v2 (original)
+++ branches/release/libs/units/test_headers/Jamfile.v2 2008-12-10 22:09:08 EST (Wed, 10 Dec 2008)
@@ -4,40 +4,45 @@
# Steven Watanabe
#
# Distributed under the Boost Software License, Version 1.0. (See
-# accomanying file LICENSE_1_0.txt or copy at
+# accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt
import testing ;
import path ;
import regex ;
import print ;
+import sequence ;
+import feature ;
-project test_headers :
+project boost/units/test_headers :
requirements <include>$(BOOST_ROOT) <include>../../..
;
headers = [ path.glob-tree ../../../boost/units : *.hpp : detail ] ;
-rule setup ( ) {
- for local file in $(headers) {
-
- result += [ compile test.cpp :
- <define>BOOST_UNITS_HEADER_NAME=$(file)
- <dependency>$(file)
- :
- [ regex.replace [ path.relative-to ../../.. $(file) ] "/" "_" ] ] ;
-
- }
- return $(result) ;
+for local file in $(headers)
+{
+ compile test.cpp
+ : # requirements
+ <define>BOOST_UNITS_HEADER_NAME=$(file)
+ <dependency>$(file)
+ : # test name
+ [ regex.replace [ path.relative-to ../../.. $(file) ] "/" "_" ] ;
}
-tests = [ setup ] ;
-
-rule generate-include-all ( target : sources * : properties * ) {
+feature.feature <generate-include-all-order> : forward reverse : incidental ;
+rule generate-include-all ( target : sources * : properties * )
+{
print.output $(target) ;
- for local file in $(sources) {
+ if <generate-include-all-order>reverse in $(properties)
+ {
+ sources = [ sequence.reverse $(sources) ] ;
+ }
+
+ for local file in $(sources)
+ {
print.text "#include <$(file:G=)>
" : overwrite ;
}
@@ -45,12 +50,7 @@
}
make include_all1.cpp : $(headers) : @generate-include-all ;
-make include_all2.cpp : $(headers) : @generate-include-all ;
-
-import testing ;
+make include_all2.cpp : $(headers) : @generate-include-all : <generate-include-all-order>reverse ;
-test-suite units_headers :
- $(tests)
# this ought to catch non-inlined functions and other duplicate definitions
- [ link include_all1.cpp include_all2.cpp main.cpp : <include>. : include_all_headers ]
- ;
+link include_all1.cpp include_all2.cpp main.cpp : <include>. : include_all_headers ;