summaryrefslogtreecommitdiff
path: root/boost/units
diff options
context:
space:
mode:
Diffstat (limited to 'boost/units')
-rw-r--r--boost/units/absolute.hpp30
-rw-r--r--boost/units/base_dimension.hpp10
-rw-r--r--boost/units/base_unit.hpp10
-rw-r--r--boost/units/base_units/angle/arcminute.hpp4
-rw-r--r--boost/units/base_units/angle/arcsecond.hpp4
-rw-r--r--boost/units/base_units/angle/revolution.hpp4
-rw-r--r--boost/units/base_units/astronomical/light_day.hpp4
-rw-r--r--boost/units/base_units/astronomical/light_hour.hpp4
-rw-r--r--boost/units/base_units/astronomical/light_minute.hpp4
-rw-r--r--boost/units/base_units/astronomical/light_year.hpp4
-rw-r--r--boost/units/base_units/imperial/drachm.hpp4
-rw-r--r--boost/units/base_units/imperial/fluid_ounce.hpp4
-rw-r--r--boost/units/base_units/imperial/foot.hpp4
-rw-r--r--boost/units/base_units/imperial/furlong.hpp4
-rw-r--r--boost/units/base_units/imperial/gallon.hpp4
-rw-r--r--boost/units/base_units/imperial/gill.hpp4
-rw-r--r--boost/units/base_units/imperial/grain.hpp4
-rw-r--r--boost/units/base_units/imperial/hundredweight.hpp4
-rw-r--r--boost/units/base_units/imperial/inch.hpp4
-rw-r--r--boost/units/base_units/imperial/league.hpp4
-rw-r--r--boost/units/base_units/imperial/mile.hpp4
-rw-r--r--boost/units/base_units/imperial/ounce.hpp4
-rw-r--r--boost/units/base_units/imperial/quart.hpp4
-rw-r--r--boost/units/base_units/imperial/quarter.hpp4
-rw-r--r--boost/units/base_units/imperial/stone.hpp4
-rw-r--r--boost/units/base_units/imperial/thou.hpp4
-rw-r--r--boost/units/base_units/imperial/ton.hpp4
-rw-r--r--boost/units/base_units/information/byte.hpp4
-rw-r--r--boost/units/base_units/information/shannon.hpp4
-rw-r--r--boost/units/base_units/metric/angstrom.hpp4
-rw-r--r--boost/units/base_units/metric/day.hpp4
-rw-r--r--boost/units/base_units/metric/fermi.hpp4
-rw-r--r--boost/units/base_units/metric/hour.hpp4
-rw-r--r--boost/units/base_units/metric/micron.hpp4
-rw-r--r--boost/units/base_units/metric/minute.hpp4
-rw-r--r--boost/units/base_units/metric/nautical_mile.hpp4
-rw-r--r--boost/units/base_units/metric/ton.hpp4
-rw-r--r--boost/units/base_units/metric/year.hpp4
-rw-r--r--boost/units/base_units/us/cup.hpp4
-rw-r--r--boost/units/base_units/us/dram.hpp4
-rw-r--r--boost/units/base_units/us/fluid_dram.hpp4
-rw-r--r--boost/units/base_units/us/fluid_ounce.hpp4
-rw-r--r--boost/units/base_units/us/foot.hpp4
-rw-r--r--boost/units/base_units/us/gallon.hpp4
-rw-r--r--boost/units/base_units/us/gill.hpp4
-rw-r--r--boost/units/base_units/us/grain.hpp4
-rw-r--r--boost/units/base_units/us/hundredweight.hpp4
-rw-r--r--boost/units/base_units/us/inch.hpp4
-rw-r--r--boost/units/base_units/us/mil.hpp4
-rw-r--r--boost/units/base_units/us/mile.hpp4
-rw-r--r--boost/units/base_units/us/minim.hpp4
-rw-r--r--boost/units/base_units/us/ounce.hpp4
-rw-r--r--boost/units/base_units/us/quart.hpp4
-rw-r--r--boost/units/base_units/us/tablespoon.hpp4
-rw-r--r--boost/units/base_units/us/teaspoon.hpp4
-rw-r--r--boost/units/base_units/us/ton.hpp4
-rw-r--r--boost/units/cmath.hpp53
-rw-r--r--boost/units/config.hpp2
-rw-r--r--boost/units/conversion.hpp19
-rw-r--r--boost/units/detail/absolute_impl.hpp8
-rw-r--r--boost/units/detail/conversion_impl.hpp50
-rw-r--r--boost/units/detail/linear_algebra.hpp10
-rw-r--r--boost/units/detail/one.hpp31
-rw-r--r--boost/units/detail/ordinal.hpp4
-rw-r--r--boost/units/detail/prevent_redefinition.hpp8
-rw-r--r--boost/units/detail/static_rational_power.hpp39
-rw-r--r--boost/units/detail/unscale.hpp23
-rw-r--r--boost/units/io.hpp14
-rw-r--r--boost/units/limits.hpp68
-rw-r--r--boost/units/operators.hpp4
-rw-r--r--boost/units/pow.hpp11
-rw-r--r--boost/units/quantity.hpp128
-rw-r--r--boost/units/scale.hpp16
-rw-r--r--boost/units/static_constant.hpp7
-rw-r--r--boost/units/static_rational.hpp22
-rw-r--r--boost/units/systems/detail/constants.hpp49
-rw-r--r--boost/units/unit.hpp18
77 files changed, 480 insertions, 366 deletions
diff --git a/boost/units/absolute.hpp b/boost/units/absolute.hpp
index c035475a40..254159455e 100644
--- a/boost/units/absolute.hpp
+++ b/boost/units/absolute.hpp
@@ -37,16 +37,16 @@ class absolute
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_) { }
+ BOOST_CONSTEXPR absolute() : val_() { }
+ BOOST_CONSTEXPR absolute(const value_type& val) : val_(val) { }
+ BOOST_CONSTEXPR absolute(const this_type& source) : val_(source.val_) { }
- this_type& operator=(const this_type& source) { val_ = source.val_; return *this; }
+ BOOST_CXX14_CONSTEXPR this_type& operator=(const this_type& source) { val_ = source.val_; return *this; }
- const value_type& value() const { return val_; }
+ BOOST_CONSTEXPR 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; }
+ BOOST_CXX14_CONSTEXPR const this_type& operator+=(const value_type& val) { val_ += val; return *this; }
+ BOOST_CXX14_CONSTEXPR const this_type& operator-=(const value_type& val) { val_ -= val; return *this; }
private:
value_type val_;
@@ -54,42 +54,42 @@ class absolute
/// add a relative value to an absolute one
template<class Y>
-absolute<Y> operator+(const absolute<Y>& aval,const Y& rval)
+BOOST_CONSTEXPR absolute<Y> operator+(const absolute<Y>& aval,const Y& rval)
{
return absolute<Y>(aval.value()+rval);
}
/// add a relative value to an absolute one
template<class Y>
-absolute<Y> operator+(const Y& rval,const absolute<Y>& aval)
+BOOST_CONSTEXPR absolute<Y> operator+(const Y& rval,const absolute<Y>& aval)
{
return absolute<Y>(aval.value()+rval);
}
/// subtract a relative value from an absolute one
template<class Y>
-absolute<Y> operator-(const absolute<Y>& aval,const Y& rval)
+BOOST_CONSTEXPR absolute<Y> operator-(const absolute<Y>& aval,const Y& rval)
{
return absolute<Y>(aval.value()-rval);
}
/// subtracting two absolutes gives a difference
template<class Y>
-Y operator-(const absolute<Y>& aval1,const absolute<Y>& aval2)
+BOOST_CONSTEXPR Y operator-(const absolute<Y>& aval1,const absolute<Y>& aval2)
{
return Y(aval1.value()-aval2.value());
}
/// creates a quantity from an absolute unit and a raw value
template<class D, class S, class T>
-quantity<absolute<unit<D, S> >, T> operator*(const T& t, const absolute<unit<D, S> >&)
+BOOST_CONSTEXPR quantity<absolute<unit<D, S> >, T> operator*(const T& t, const absolute<unit<D, S> >&)
{
return(quantity<absolute<unit<D, S> >, T>::from_value(t));
}
/// creates a quantity from an absolute unit and a raw value
template<class D, class S, class T>
-quantity<absolute<unit<D, S> >, T> operator*(const absolute<unit<D, S> >&, const T& t)
+BOOST_CONSTEXPR quantity<absolute<unit<D, S> >, T> operator*(const absolute<unit<D, S> >&, const T& t)
{
return(quantity<absolute<unit<D, S> >, T>::from_value(t));
}
@@ -138,9 +138,9 @@ namespace units {
reduce_unit<From::unit_type>::type, \
reduce_unit<To::unit_type>::type> \
{ \
- static const bool is_defined = true; \
+ BOOST_STATIC_CONSTEXPR bool is_defined = true; \
typedef type_ type; \
- static type value() { return(value_); } \
+ static BOOST_CONSTEXPR type value() { return(value_); } \
}; \
} \
} \
diff --git a/boost/units/base_dimension.hpp b/boost/units/base_dimension.hpp
index a635aa66c7..430f019e6b 100644
--- a/boost/units/base_dimension.hpp
+++ b/boost/units/base_dimension.hpp
@@ -83,21 +83,21 @@ class base_dimension :
/// check_base_dimension will trigger an error earlier
/// for compilers with less strict name lookup.
/// INTERNAL ONLY
- friend Derived*
+ friend BOOST_CONSTEXPR Derived*
check_double_register(const units::base_dimension_ordinal<N>&)
{ return(0); }
/// Register this ordinal
/// INTERNAL ONLY
- friend detail::yes
+ friend BOOST_CONSTEXPR detail::yes
boost_units_is_registered(const units::base_dimension_ordinal<N>&)
- { detail::yes result; return(result); }
+ { return(detail::yes()); }
/// But make sure we can identify the current instantiation!
/// INTERNAL ONLY
- friend detail::yes
+ friend BOOST_CONSTEXPR detail::yes
boost_units_is_registered(const units::base_dimension_pair<Derived, N>&)
- { detail::yes result; return(result); }
+ { return(detail::yes()); }
};
} // namespace units
diff --git a/boost/units/base_unit.hpp b/boost/units/base_unit.hpp
index 94fc416577..b66558a66b 100644
--- a/boost/units/base_unit.hpp
+++ b/boost/units/base_unit.hpp
@@ -104,21 +104,21 @@ class base_unit :
/// check_base_unit will trigger an error earlier
/// for compilers with less strict name lookup.
/// INTERNAL ONLY
- friend Derived*
+ friend BOOST_CONSTEXPR Derived*
check_double_register(const units::base_unit_ordinal<N>&)
{ return(0); }
/// Register this ordinal
/// INTERNAL ONLY
- friend detail::yes
+ friend BOOST_CONSTEXPR detail::yes
boost_units_unit_is_registered(const units::base_unit_ordinal<N>&)
- { detail::yes result; return(result); }
+ { return(detail::yes()); }
/// But make sure we can identify the current instantiation!
/// INTERNAL ONLY
- friend detail::yes
+ friend BOOST_CONSTEXPR detail::yes
boost_units_unit_is_registered(const units::base_unit_pair<Derived, N>&)
- { detail::yes result; return(result); }
+ { return(detail::yes()); }
};
} // namespace units
diff --git a/boost/units/base_units/angle/arcminute.hpp b/boost/units/base_units/angle/arcminute.hpp
index 86bf5e0fa3..27570fbbbb 100644
--- a/boost/units/base_units/angle/arcminute.hpp
+++ b/boost/units/base_units/angle/arcminute.hpp
@@ -26,8 +26,8 @@ typedef scaled_base_unit<degree_base_unit, scale<60, static_rational<-1> > > ar
template<>
struct base_unit_info<angle::arcminute_base_unit> {
- static const char* name() { return("arcminute"); }
- static const char* symbol() { return("'"); }
+ static BOOST_CONSTEXPR const char* name() { return("arcminute"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("'"); }
};
}
diff --git a/boost/units/base_units/angle/arcsecond.hpp b/boost/units/base_units/angle/arcsecond.hpp
index 8baabfa6ec..97851ffb70 100644
--- a/boost/units/base_units/angle/arcsecond.hpp
+++ b/boost/units/base_units/angle/arcsecond.hpp
@@ -27,8 +27,8 @@ typedef scaled_base_unit<degree_base_unit, scale<3600, static_rational<-1> > >
template<>
struct base_unit_info<angle::arcsecond_base_unit> {
- static const char* name() { return("arcsecond"); }
- static const char* symbol() { return("\""); }
+ static BOOST_CONSTEXPR const char* name() { return("arcsecond"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("\""); }
};
}
diff --git a/boost/units/base_units/angle/revolution.hpp b/boost/units/base_units/angle/revolution.hpp
index 2dd0d5b9bf..3d576286ef 100644
--- a/boost/units/base_units/angle/revolution.hpp
+++ b/boost/units/base_units/angle/revolution.hpp
@@ -26,8 +26,8 @@ typedef scaled_base_unit<degree_base_unit, scale<360, static_rational<1> > > re
template<>
struct base_unit_info<angle::revolution_base_unit> {
- static const char* name() { return("revolution"); }
- static const char* symbol() { return("rev"); }
+ static BOOST_CONSTEXPR const char* name() { return("revolution"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("rev"); }
};
}
diff --git a/boost/units/base_units/astronomical/light_day.hpp b/boost/units/base_units/astronomical/light_day.hpp
index 2d045ff2e1..a0ad93becb 100644
--- a/boost/units/base_units/astronomical/light_day.hpp
+++ b/boost/units/base_units/astronomical/light_day.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<boost::units::astronomical::light_second_base_unit, sca
template<>
struct base_unit_info<astronomical::light_day_base_unit> {
- static const char* name() { return("light day"); }
- static const char* symbol() { return("ldy"); }
+ static BOOST_CONSTEXPR const char* name() { return("light day"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("ldy"); }
};
} // namespace units
diff --git a/boost/units/base_units/astronomical/light_hour.hpp b/boost/units/base_units/astronomical/light_hour.hpp
index 207d951a46..91bc09a28c 100644
--- a/boost/units/base_units/astronomical/light_hour.hpp
+++ b/boost/units/base_units/astronomical/light_hour.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<boost::units::astronomical::light_second_base_unit, sca
template<>
struct base_unit_info<astronomical::light_hour_base_unit> {
- static const char* name() { return("light hour"); }
- static const char* symbol() { return("lhr"); }
+ static BOOST_CONSTEXPR const char* name() { return("light hour"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("lhr"); }
};
} // namespace units
diff --git a/boost/units/base_units/astronomical/light_minute.hpp b/boost/units/base_units/astronomical/light_minute.hpp
index f0bd095636..6301745c29 100644
--- a/boost/units/base_units/astronomical/light_minute.hpp
+++ b/boost/units/base_units/astronomical/light_minute.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<boost::units::astronomical::light_second_base_unit, sca
template<>
struct base_unit_info<astronomical::light_minute_base_unit> {
- static const char* name() { return("light minute"); }
- static const char* symbol() { return("lmn"); }
+ static BOOST_CONSTEXPR const char* name() { return("light minute"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("lmn"); }
};
} // namespace units
diff --git a/boost/units/base_units/astronomical/light_year.hpp b/boost/units/base_units/astronomical/light_year.hpp
index e9e83a3acb..f3434a7918 100644
--- a/boost/units/base_units/astronomical/light_year.hpp
+++ b/boost/units/base_units/astronomical/light_year.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<boost::units::astronomical::light_second_base_unit, sca
template<>
struct base_unit_info<astronomical::light_year_base_unit> {
- static const char* name() { return("light year"); }
- static const char* symbol() { return("ly"); }
+ static BOOST_CONSTEXPR const char* name() { return("light year"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("ly"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/drachm.hpp b/boost/units/base_units/imperial/drachm.hpp
index 3dcc024074..b965040c3b 100644
--- a/boost/units/base_units/imperial/drachm.hpp
+++ b/boost/units/base_units/imperial/drachm.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<16, static_rational<-2> > > drac
template<>
struct base_unit_info<imperial::drachm_base_unit> {
- static const char* name() { return("drachm"); }
- static const char* symbol() { return("drachm"); }
+ static BOOST_CONSTEXPR const char* name() { return("drachm"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("drachm"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/fluid_ounce.hpp b/boost/units/base_units/imperial/fluid_ounce.hpp
index 8bab33eb2d..b318fb2c9f 100644
--- a/boost/units/base_units/imperial/fluid_ounce.hpp
+++ b/boost/units/base_units/imperial/fluid_ounce.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<20, static_rational<-1> > > fluid
template<>
struct base_unit_info<imperial::fluid_ounce_base_unit> {
- static const char* name() { return("fluid ounce (imp.)"); }
- static const char* symbol() { return("fl oz"); }
+ static BOOST_CONSTEXPR const char* name() { return("fluid ounce (imp.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("fl oz"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/foot.hpp b/boost/units/base_units/imperial/foot.hpp
index 149985e867..429c77c7b0 100644
--- a/boost/units/base_units/imperial/foot.hpp
+++ b/boost/units/base_units/imperial/foot.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<3, static_rational<-1> > > foot_b
template<>
struct base_unit_info<imperial::foot_base_unit> {
- static const char* name() { return("foot"); }
- static const char* symbol() { return("ft"); }
+ static BOOST_CONSTEXPR const char* name() { return("foot"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("ft"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/furlong.hpp b/boost/units/base_units/imperial/furlong.hpp
index 1d988214ae..8851f2c0e9 100644
--- a/boost/units/base_units/imperial/furlong.hpp
+++ b/boost/units/base_units/imperial/furlong.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<220, static_rational<1> > > furlo
template<>
struct base_unit_info<imperial::furlong_base_unit> {
- static const char* name() { return("furlong"); }
- static const char* symbol() { return("furlong"); }
+ static BOOST_CONSTEXPR const char* name() { return("furlong"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("furlong"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/gallon.hpp b/boost/units/base_units/imperial/gallon.hpp
index 6fd46538ff..c0e1513631 100644
--- a/boost/units/base_units/imperial/gallon.hpp
+++ b/boost/units/base_units/imperial/gallon.hpp
@@ -29,8 +29,8 @@ typedef scaled_base_unit<pint_base_unit, scale<8, static_rational<1> > > gallon_
template<>
struct base_unit_info<imperial::gallon_base_unit> {
- static const char* name() { return("gallon (imp.)"); }
- static const char* symbol() { return("gal"); }
+ static BOOST_CONSTEXPR const char* name() { return("gallon (imp.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("gal"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/gill.hpp b/boost/units/base_units/imperial/gill.hpp
index 3e5b83af3e..353a46b409 100644
--- a/boost/units/base_units/imperial/gill.hpp
+++ b/boost/units/base_units/imperial/gill.hpp
@@ -29,8 +29,8 @@ typedef scaled_base_unit<pint_base_unit, scale<4, static_rational<-1> > > gill_b
template<>
struct base_unit_info<imperial::gill_base_unit> {
- static const char* name() { return("gill (imp.)"); }
- static const char* symbol() { return("gill"); }
+ static BOOST_CONSTEXPR const char* name() { return("gill (imp.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("gill"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/grain.hpp b/boost/units/base_units/imperial/grain.hpp
index a36b4a4d2e..7567f9912e 100644
--- a/boost/units/base_units/imperial/grain.hpp
+++ b/boost/units/base_units/imperial/grain.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<7000, static_rational<-1> > > gr
template<>
struct base_unit_info<imperial::grain_base_unit> {
- static const char* name() { return("grain"); }
- static const char* symbol() { return("grain"); }
+ static BOOST_CONSTEXPR const char* name() { return("grain"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("grain"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/hundredweight.hpp b/boost/units/base_units/imperial/hundredweight.hpp
index 6709a788e0..8f03763ff6 100644
--- a/boost/units/base_units/imperial/hundredweight.hpp
+++ b/boost/units/base_units/imperial/hundredweight.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<112, static_rational<1> > > hund
template<>
struct base_unit_info<imperial::hundredweight_base_unit> {
- static const char* name() { return("hundredweight"); }
- static const char* symbol() { return("cwt"); }
+ static BOOST_CONSTEXPR const char* name() { return("hundredweight"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("cwt"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/inch.hpp b/boost/units/base_units/imperial/inch.hpp
index 048d8c6710..d39c332342 100644
--- a/boost/units/base_units/imperial/inch.hpp
+++ b/boost/units/base_units/imperial/inch.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<36, static_rational<-1> > > inch_
template<>
struct base_unit_info<imperial::inch_base_unit> {
- static const char* name() { return("inch"); }
- static const char* symbol() { return("in"); }
+ static BOOST_CONSTEXPR const char* name() { return("inch"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("in"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/league.hpp b/boost/units/base_units/imperial/league.hpp
index 991e4b6025..87c0cfb575 100644
--- a/boost/units/base_units/imperial/league.hpp
+++ b/boost/units/base_units/imperial/league.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<5280, static_rational<1> > > leag
template<>
struct base_unit_info<imperial::league_base_unit> {
- static const char* name() { return("league"); }
- static const char* symbol() { return("league"); }
+ static BOOST_CONSTEXPR const char* name() { return("league"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("league"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/mile.hpp b/boost/units/base_units/imperial/mile.hpp
index d0d0fb5a15..230537f5b3 100644
--- a/boost/units/base_units/imperial/mile.hpp
+++ b/boost/units/base_units/imperial/mile.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<1760, static_rational<1> > > mile
template<>
struct base_unit_info<imperial::mile_base_unit> {
- static const char* name() { return("mile"); }
- static const char* symbol() { return("mi"); }
+ static BOOST_CONSTEXPR const char* name() { return("mile"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("mi"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/ounce.hpp b/boost/units/base_units/imperial/ounce.hpp
index 8b9e33afc9..05bfcc1594 100644
--- a/boost/units/base_units/imperial/ounce.hpp
+++ b/boost/units/base_units/imperial/ounce.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<2, static_rational<-4> > > ounce
template<>
struct base_unit_info<imperial::ounce_base_unit> {
- static const char* name() { return("ounce"); }
- static const char* symbol() { return("oz"); }
+ static BOOST_CONSTEXPR const char* name() { return("ounce"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("oz"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/quart.hpp b/boost/units/base_units/imperial/quart.hpp
index 723ce0b4a2..f4c0a00995 100644
--- a/boost/units/base_units/imperial/quart.hpp
+++ b/boost/units/base_units/imperial/quart.hpp
@@ -29,8 +29,8 @@ typedef scaled_base_unit<pint_base_unit, scale<2, static_rational<1> > > quart_b
template<>
struct base_unit_info<imperial::quart_base_unit> {
- static const char* name() { return("quart (imp.)"); }
- static const char* symbol() { return("qt"); }
+ static BOOST_CONSTEXPR const char* name() { return("quart (imp.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("qt"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/quarter.hpp b/boost/units/base_units/imperial/quarter.hpp
index 30f0594fad..912d51d78d 100644
--- a/boost/units/base_units/imperial/quarter.hpp
+++ b/boost/units/base_units/imperial/quarter.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<28, static_rational<1> > > quart
template<>
struct base_unit_info<imperial::quarter_base_unit> {
- static const char* name() { return("quarter"); }
- static const char* symbol() { return("quarter"); }
+ static BOOST_CONSTEXPR const char* name() { return("quarter"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("quarter"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/stone.hpp b/boost/units/base_units/imperial/stone.hpp
index b4ce433838..1b260a29e3 100644
--- a/boost/units/base_units/imperial/stone.hpp
+++ b/boost/units/base_units/imperial/stone.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<14, static_rational<1> > > stone
template<>
struct base_unit_info<imperial::stone_base_unit> {
- static const char* name() { return("stone"); }
- static const char* symbol() { return("st"); }
+ static BOOST_CONSTEXPR const char* name() { return("stone"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("st"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/thou.hpp b/boost/units/base_units/imperial/thou.hpp
index eab2ac9e4e..af1f911e46 100644
--- a/boost/units/base_units/imperial/thou.hpp
+++ b/boost/units/base_units/imperial/thou.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<36000, static_rational<-1> > > th
template<>
struct base_unit_info<imperial::thou_base_unit> {
- static const char* name() { return("thou"); }
- static const char* symbol() { return("thou"); }
+ static BOOST_CONSTEXPR const char* name() { return("thou"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("thou"); }
};
} // namespace units
diff --git a/boost/units/base_units/imperial/ton.hpp b/boost/units/base_units/imperial/ton.hpp
index 867f14738c..a1f709ec6b 100644
--- a/boost/units/base_units/imperial/ton.hpp
+++ b/boost/units/base_units/imperial/ton.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<2240, static_rational<1> > > ton
template<>
struct base_unit_info<imperial::ton_base_unit> {
- static const char* name() { return("long ton"); }
- static const char* symbol() { return("t"); }
+ static BOOST_CONSTEXPR const char* name() { return("long ton"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("t"); }
};
} // namespace units
diff --git a/boost/units/base_units/information/byte.hpp b/boost/units/base_units/information/byte.hpp
index 6cd9692d3b..6dcfde2557 100644
--- a/boost/units/base_units/information/byte.hpp
+++ b/boost/units/base_units/information/byte.hpp
@@ -26,8 +26,8 @@ typedef scaled_base_unit<boost::units::information::bit_base_unit, scale<2, stat
template<>
struct base_unit_info<information::byte_base_unit> {
- static const char* name() { return("byte"); }
- static const char* symbol() { return("B"); }
+ static BOOST_CONSTEXPR const char* name() { return("byte"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("B"); }
};
} // namespace units
diff --git a/boost/units/base_units/information/shannon.hpp b/boost/units/base_units/information/shannon.hpp
index b52bf7afb9..60e37b2cd9 100644
--- a/boost/units/base_units/information/shannon.hpp
+++ b/boost/units/base_units/information/shannon.hpp
@@ -26,8 +26,8 @@ typedef scaled_base_unit<boost::units::information::bit_base_unit, scale<1, stat
template<>
struct base_unit_info<information::shannon_base_unit> {
- static const char* name() { return("shannon"); }
- static const char* symbol() { return("Sh"); }
+ static BOOST_CONSTEXPR const char* name() { return("shannon"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("Sh"); }
};
} // namespace units
diff --git a/boost/units/base_units/metric/angstrom.hpp b/boost/units/base_units/metric/angstrom.hpp
index d2954e3114..64cc3379be 100644
--- a/boost/units/base_units/metric/angstrom.hpp
+++ b/boost/units/base_units/metric/angstrom.hpp
@@ -27,8 +27,8 @@ typedef scaled_base_unit<boost::units::si::meter_base_unit, scale<10, static_rat
template<>
struct base_unit_info<metric::angstrom_base_unit> {
- static const char* name() { return("angstrom"); }
- static const char* symbol() { return("A"); }
+ static BOOST_CONSTEXPR const char* name() { return("angstrom"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("A"); }
};
}
diff --git a/boost/units/base_units/metric/day.hpp b/boost/units/base_units/metric/day.hpp
index f8d83c8af8..ac111c9ee0 100644
--- a/boost/units/base_units/metric/day.hpp
+++ b/boost/units/base_units/metric/day.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<boost::units::si::second_base_unit, scale<86400, static
template<>
struct base_unit_info<metric::day_base_unit> {
- static const char* name() { return("day"); }
- static const char* symbol() { return("d"); }
+ static BOOST_CONSTEXPR const char* name() { return("day"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("d"); }
};
} // namespace units
diff --git a/boost/units/base_units/metric/fermi.hpp b/boost/units/base_units/metric/fermi.hpp
index 8732c4ef01..f12c903f49 100644
--- a/boost/units/base_units/metric/fermi.hpp
+++ b/boost/units/base_units/metric/fermi.hpp
@@ -26,8 +26,8 @@ typedef scaled_base_unit<boost::units::si::meter_base_unit, scale<10, static_rat
template<>
struct base_unit_info<metric::fermi_base_unit> {
- static const char* name() { return("fermi"); }
- static const char* symbol() { return("fm"); }
+ static BOOST_CONSTEXPR const char* name() { return("fermi"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("fm"); }
};
}
diff --git a/boost/units/base_units/metric/hour.hpp b/boost/units/base_units/metric/hour.hpp
index 443e250378..65657ce030 100644
--- a/boost/units/base_units/metric/hour.hpp
+++ b/boost/units/base_units/metric/hour.hpp
@@ -27,8 +27,8 @@ typedef scaled_base_unit<boost::units::si::second_base_unit, scale<60, static_ra
template<>
struct base_unit_info<metric::hour_base_unit> {
- static const char* name() { return("hour"); }
- static const char* symbol() { return("h"); }
+ static BOOST_CONSTEXPR const char* name() { return("hour"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("h"); }
};
}
diff --git a/boost/units/base_units/metric/micron.hpp b/boost/units/base_units/metric/micron.hpp
index 0965836079..c169cfdb32 100644
--- a/boost/units/base_units/metric/micron.hpp
+++ b/boost/units/base_units/metric/micron.hpp
@@ -26,8 +26,8 @@ typedef scaled_base_unit<boost::units::si::meter_base_unit, scale<10, static_rat
template<>
struct base_unit_info<metric::micron_base_unit> {
- static const char* name() { return("micron"); }
- static const char* symbol() { return("u"); }
+ static BOOST_CONSTEXPR const char* name() { return("micron"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("u"); }
};
}
diff --git a/boost/units/base_units/metric/minute.hpp b/boost/units/base_units/metric/minute.hpp
index c2f9e6b397..3c0a68fc2c 100644
--- a/boost/units/base_units/metric/minute.hpp
+++ b/boost/units/base_units/metric/minute.hpp
@@ -27,8 +27,8 @@ typedef scaled_base_unit<boost::units::si::second_base_unit, scale<60, static_ra
template<>
struct base_unit_info<metric::minute_base_unit> {
- static const char* name() { return("minute"); }
- static const char* symbol() { return("min"); }
+ static BOOST_CONSTEXPR const char* name() { return("minute"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("min"); }
};
}
diff --git a/boost/units/base_units/metric/nautical_mile.hpp b/boost/units/base_units/metric/nautical_mile.hpp
index d42dd77e4b..4f20951af8 100644
--- a/boost/units/base_units/metric/nautical_mile.hpp
+++ b/boost/units/base_units/metric/nautical_mile.hpp
@@ -26,8 +26,8 @@ typedef scaled_base_unit<boost::units::si::meter_base_unit, scale<1852, static_r
template<>
struct base_unit_info<metric::nautical_mile_base_unit> {
- static const char* name() { return("nautical mile"); }
- static const char* symbol() { return("nmi"); }
+ static BOOST_CONSTEXPR const char* name() { return("nautical mile"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("nmi"); }
};
}
diff --git a/boost/units/base_units/metric/ton.hpp b/boost/units/base_units/metric/ton.hpp
index a842aaab00..4f8e9643cd 100644
--- a/boost/units/base_units/metric/ton.hpp
+++ b/boost/units/base_units/metric/ton.hpp
@@ -29,8 +29,8 @@ typedef scaled_base_unit<boost::units::si::kilogram_base_unit, scale<1000, stati
template<>
struct base_unit_info<metric::ton_base_unit> {
- static const char* name() { return("metric ton"); }
- static const char* symbol() { return("t"); }
+ static BOOST_CONSTEXPR const char* name() { return("metric ton"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("t"); }
};
}
diff --git a/boost/units/base_units/metric/year.hpp b/boost/units/base_units/metric/year.hpp
index e43acd6dd6..5d715e2de1 100644
--- a/boost/units/base_units/metric/year.hpp
+++ b/boost/units/base_units/metric/year.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<boost::units::si::second_base_unit, scale<31557600, sta
template<>
struct base_unit_info<metric::year_base_unit> {
- static const char* name() { return("Julian year"); }
- static const char* symbol() { return("yr"); }
+ static BOOST_CONSTEXPR const char* name() { return("Julian year"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("yr"); }
};
}
diff --git a/boost/units/base_units/us/cup.hpp b/boost/units/base_units/us/cup.hpp
index f811373304..86b408322c 100644
--- a/boost/units/base_units/us/cup.hpp
+++ b/boost/units/base_units/us/cup.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<2, static_rational<-1> > > cup_ba
template<>
struct base_unit_info<us::cup_base_unit> {
- static const char* name() { return("cup"); }
- static const char* symbol() { return("c"); }
+ static BOOST_CONSTEXPR const char* name() { return("cup"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("c"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/dram.hpp b/boost/units/base_units/us/dram.hpp
index 73fc44ff31..29e08d9e79 100644
--- a/boost/units/base_units/us/dram.hpp
+++ b/boost/units/base_units/us/dram.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<16, static_rational<-2> > > dram
template<>
struct base_unit_info<us::dram_base_unit> {
- static const char* name() { return("dram (U.S.)"); }
- static const char* symbol() { return("dr"); }
+ static BOOST_CONSTEXPR const char* name() { return("dram (U.S.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("dr"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/fluid_dram.hpp b/boost/units/base_units/us/fluid_dram.hpp
index cf0c85d3c7..0b9c60d766 100644
--- a/boost/units/base_units/us/fluid_dram.hpp
+++ b/boost/units/base_units/us/fluid_dram.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<2, static_rational<-7> > > fluid_
template<>
struct base_unit_info<us::fluid_dram_base_unit> {
- static const char* name() { return("fluid dram (U.S.)"); }
- static const char* symbol() { return("fl dr"); }
+ static BOOST_CONSTEXPR const char* name() { return("fluid dram (U.S.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("fl dr"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/fluid_ounce.hpp b/boost/units/base_units/us/fluid_ounce.hpp
index 0c9d7e9943..c7f0f07ee8 100644
--- a/boost/units/base_units/us/fluid_ounce.hpp
+++ b/boost/units/base_units/us/fluid_ounce.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<16, static_rational<-1> > > fluid
template<>
struct base_unit_info<us::fluid_ounce_base_unit> {
- static const char* name() { return("fluid ounce (U.S.)"); }
- static const char* symbol() { return("fl oz"); }
+ static BOOST_CONSTEXPR const char* name() { return("fluid ounce (U.S.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("fl oz"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/foot.hpp b/boost/units/base_units/us/foot.hpp
index 4b529bb6a4..16cbf6d2b4 100644
--- a/boost/units/base_units/us/foot.hpp
+++ b/boost/units/base_units/us/foot.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<3, static_rational<-1> > > foot_b
template<>
struct base_unit_info<us::foot_base_unit> {
- static const char* name() { return("foot"); }
- static const char* symbol() { return("ft"); }
+ static BOOST_CONSTEXPR const char* name() { return("foot"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("ft"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/gallon.hpp b/boost/units/base_units/us/gallon.hpp
index a7314c58e4..1b54b28f19 100644
--- a/boost/units/base_units/us/gallon.hpp
+++ b/boost/units/base_units/us/gallon.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<2, static_rational<3> > > gallon_
template<>
struct base_unit_info<us::gallon_base_unit> {
- static const char* name() { return("gallon (U.S.)"); }
- static const char* symbol() { return("gal"); }
+ static BOOST_CONSTEXPR const char* name() { return("gallon (U.S.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("gal"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/gill.hpp b/boost/units/base_units/us/gill.hpp
index e9373439b6..c654386a21 100644
--- a/boost/units/base_units/us/gill.hpp
+++ b/boost/units/base_units/us/gill.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<2, static_rational<-2> > > gill_b
template<>
struct base_unit_info<us::gill_base_unit> {
- static const char* name() { return("gill (U.S.)"); }
- static const char* symbol() { return("gi"); }
+ static BOOST_CONSTEXPR const char* name() { return("gill (U.S.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("gi"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/grain.hpp b/boost/units/base_units/us/grain.hpp
index e21baf6916..485b68723f 100644
--- a/boost/units/base_units/us/grain.hpp
+++ b/boost/units/base_units/us/grain.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<7000, static_rational<-1> > > gr
template<>
struct base_unit_info<us::grain_base_unit> {
- static const char* name() { return("grain"); }
- static const char* symbol() { return("gr"); }
+ static BOOST_CONSTEXPR const char* name() { return("grain"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("gr"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/hundredweight.hpp b/boost/units/base_units/us/hundredweight.hpp
index 0bccd4922e..2ac991b975 100644
--- a/boost/units/base_units/us/hundredweight.hpp
+++ b/boost/units/base_units/us/hundredweight.hpp
@@ -29,8 +29,8 @@ typedef scaled_base_unit<pound_base_unit, scale<100, static_rational<1> > > hund
template<>
struct base_unit_info<us::hundredweight_base_unit> {
- static const char* name() { return("hundredweight (U.S.)"); }
- static const char* symbol() { return("cwt"); }
+ static BOOST_CONSTEXPR const char* name() { return("hundredweight (U.S.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("cwt"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/inch.hpp b/boost/units/base_units/us/inch.hpp
index 05bd59a248..e7bd91da5a 100644
--- a/boost/units/base_units/us/inch.hpp
+++ b/boost/units/base_units/us/inch.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<36, static_rational<-1> > > inch_
template<>
struct base_unit_info<us::inch_base_unit> {
- static const char* name() { return("inch"); }
- static const char* symbol() { return("in"); }
+ static BOOST_CONSTEXPR const char* name() { return("inch"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("in"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/mil.hpp b/boost/units/base_units/us/mil.hpp
index ee75b79ab8..e3276fe7b8 100644
--- a/boost/units/base_units/us/mil.hpp
+++ b/boost/units/base_units/us/mil.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<36000, static_rational<-1> > > mi
template<>
struct base_unit_info<us::mil_base_unit> {
- static const char* name() { return("mil"); }
- static const char* symbol() { return("mil"); }
+ static BOOST_CONSTEXPR const char* name() { return("mil"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("mil"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/mile.hpp b/boost/units/base_units/us/mile.hpp
index d3513f13d0..c62c0d5fc8 100644
--- a/boost/units/base_units/us/mile.hpp
+++ b/boost/units/base_units/us/mile.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<yard_base_unit, scale<1760, static_rational<1> > > mile
template<>
struct base_unit_info<us::mile_base_unit> {
- static const char* name() { return("mile"); }
- static const char* symbol() { return("mi"); }
+ static BOOST_CONSTEXPR const char* name() { return("mile"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("mi"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/minim.hpp b/boost/units/base_units/us/minim.hpp
index bf266cdba4..d877e2652c 100644
--- a/boost/units/base_units/us/minim.hpp
+++ b/boost/units/base_units/us/minim.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<7680, static_rational<-1> > > min
template<>
struct base_unit_info<us::minim_base_unit> {
- static const char* name() { return("minim (U.S.)"); }
- static const char* symbol() { return("minim"); }
+ static BOOST_CONSTEXPR const char* name() { return("minim (U.S.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("minim"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/ounce.hpp b/boost/units/base_units/us/ounce.hpp
index 5f88f8386f..9a4ec3e63a 100644
--- a/boost/units/base_units/us/ounce.hpp
+++ b/boost/units/base_units/us/ounce.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<2, static_rational<-4> > > ounce
template<>
struct base_unit_info<us::ounce_base_unit> {
- static const char* name() { return("ounce"); }
- static const char* symbol() { return("oz"); }
+ static BOOST_CONSTEXPR const char* name() { return("ounce"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("oz"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/quart.hpp b/boost/units/base_units/us/quart.hpp
index 45cf6a961a..b39252a418 100644
--- a/boost/units/base_units/us/quart.hpp
+++ b/boost/units/base_units/us/quart.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<2, static_rational<1> > > quart_b
template<>
struct base_unit_info<us::quart_base_unit> {
- static const char* name() { return("quart (U.S.)"); }
- static const char* symbol() { return("qt"); }
+ static BOOST_CONSTEXPR const char* name() { return("quart (U.S.)"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("qt"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/tablespoon.hpp b/boost/units/base_units/us/tablespoon.hpp
index f95f0a2b9a..43418ed3eb 100644
--- a/boost/units/base_units/us/tablespoon.hpp
+++ b/boost/units/base_units/us/tablespoon.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<2, static_rational<-5> > > tables
template<>
struct base_unit_info<us::tablespoon_base_unit> {
- static const char* name() { return("tablespoon"); }
- static const char* symbol() { return("tbsp"); }
+ static BOOST_CONSTEXPR const char* name() { return("tablespoon"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("tbsp"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/teaspoon.hpp b/boost/units/base_units/us/teaspoon.hpp
index 8f8dd73d1c..94fe655b7e 100644
--- a/boost/units/base_units/us/teaspoon.hpp
+++ b/boost/units/base_units/us/teaspoon.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pint_base_unit, scale<96, static_rational<-1> > > teasp
template<>
struct base_unit_info<us::teaspoon_base_unit> {
- static const char* name() { return("teaspoon"); }
- static const char* symbol() { return("tsp"); }
+ static BOOST_CONSTEXPR const char* name() { return("teaspoon"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("tsp"); }
};
} // namespace units
diff --git a/boost/units/base_units/us/ton.hpp b/boost/units/base_units/us/ton.hpp
index 84daa85a73..d1f52e8319 100644
--- a/boost/units/base_units/us/ton.hpp
+++ b/boost/units/base_units/us/ton.hpp
@@ -28,8 +28,8 @@ typedef scaled_base_unit<pound_base_unit, scale<2000, static_rational<1> > > ton
template<>
struct base_unit_info<us::ton_base_unit> {
- static const char* name() { return("short ton"); }
- static const char* symbol() { return("t"); }
+ static BOOST_CONSTEXPR const char* name() { return("short ton"); }
+ static BOOST_CONSTEXPR const char* symbol() { return("t"); }
};
} // namespace units
diff --git a/boost/units/cmath.hpp b/boost/units/cmath.hpp
index 238b31c3d3..da3da46f46 100644
--- a/boost/units/cmath.hpp
+++ b/boost/units/cmath.hpp
@@ -47,6 +47,7 @@ namespace units {
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
isfinite BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -56,6 +57,7 @@ isfinite BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
isinf BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -65,6 +67,7 @@ isinf BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
isnan BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -74,6 +77,7 @@ isnan BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
isnormal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -83,6 +87,7 @@ isnormal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
isgreater BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -93,6 +98,7 @@ isgreater BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
isgreaterequal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -103,6 +109,7 @@ isgreaterequal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
isless BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -113,6 +120,7 @@ isless BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
islessequal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -123,6 +131,7 @@ islessequal BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -133,6 +142,7 @@ islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
bool
isunordered BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -143,6 +153,7 @@ isunordered BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
abs BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -155,6 +166,7 @@ abs BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
ceil BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -167,6 +179,7 @@ ceil BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
copysign BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -180,6 +193,7 @@ copysign BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
fabs BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -192,6 +206,7 @@ fabs BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
floor BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -204,6 +219,7 @@ floor BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
fdim BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -219,6 +235,7 @@ fdim BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit1,class Unit2,class Unit3,class Y>
inline
+BOOST_CONSTEXPR
typename add_typeof_helper<
typename multiply_typeof_helper<quantity<Unit1,Y>,
quantity<Unit2,Y> >::type,
@@ -243,6 +260,7 @@ fma BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit1,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
fmax BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -256,6 +274,7 @@ fmax BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
fmin BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
@@ -269,6 +288,7 @@ fmin BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
int
fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -279,6 +299,7 @@ fpclassify BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
typename root_typeof_helper<
typename add_typeof_helper<
typename power_typeof_helper<quantity<Unit,Y>,
@@ -302,6 +323,7 @@ hypot BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,const quantit
// does ISO C++ support long long? g++ claims not
//template<class Unit,class Y>
//inline
+//BOOST_CONSTEXPR
//quantity<Unit,long long>
//llrint BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
//{
@@ -315,6 +337,7 @@ hypot BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,const quantit
// does ISO C++ support long long? g++ claims not
//template<class Unit,class Y>
//inline
+//BOOST_CONSTEXPR
//quantity<Unit,long long>
//llround BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
//{
@@ -329,6 +352,7 @@ hypot BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,const quantit
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
nearbyint BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -343,6 +367,7 @@ nearbyint BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y> nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
{
@@ -354,6 +379,7 @@ quantity<Unit,Y> nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit
}
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y> nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
const quantity<Unit,Y>& q2)
{
@@ -371,6 +397,7 @@ quantity<Unit,Y> nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Uni
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
rint BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -385,6 +412,7 @@ rint BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
round BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -397,6 +425,7 @@ round BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
int
signbit BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -407,6 +436,7 @@ signbit BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit,Y>
trunc BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
{
@@ -419,6 +449,7 @@ trunc BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit, Y>
fmod(const quantity<Unit,Y>& q1, const quantity<Unit,Y>& q2)
{
@@ -431,6 +462,7 @@ fmod(const quantity<Unit,Y>& q1, const quantity<Unit,Y>& q2)
template<class Unit, class Y>
inline
+BOOST_CONSTEXPR
quantity<Unit, Y>
modf(const quantity<Unit, Y>& q1, quantity<Unit, Y>* q2)
{
@@ -443,6 +475,7 @@ modf(const quantity<Unit, Y>& q1, quantity<Unit, Y>* q2)
template<class Unit, class Y, class Int>
inline
+BOOST_CONSTEXPR
quantity<Unit, Y>
frexp(const quantity<Unit, Y>& q,Int* ex)
{
@@ -457,6 +490,7 @@ frexp(const quantity<Unit, Y>& q,Int* ex)
/// and roots can be computed by @c pow<Ex> and @c root<Rt> respectively.
template<class S, class Y>
inline
+BOOST_CONSTEXPR
quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>
pow(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q1,
const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q2)
@@ -470,6 +504,7 @@ pow(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q1,
template<class S, class Y>
inline
+BOOST_CONSTEXPR
quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>
exp(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q)
{
@@ -482,6 +517,7 @@ exp(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q)
template<class Unit, class Y, class Int>
inline
+BOOST_CONSTEXPR
quantity<Unit, Y>
ldexp(const quantity<Unit, Y>& q,const Int& ex)
{
@@ -494,6 +530,7 @@ ldexp(const quantity<Unit, Y>& q,const Int& ex)
template<class S, class Y>
inline
+BOOST_CONSTEXPR
quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>
log(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q)
{
@@ -506,6 +543,7 @@ log(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q)
template<class S, class Y>
inline
+BOOST_CONSTEXPR
quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>
log10(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q)
{
@@ -518,6 +556,7 @@ log10(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(S), Y>& q)
template<class Unit,class Y>
inline
+BOOST_CONSTEXPR
typename root_typeof_helper<
quantity<Unit,Y>,
static_rational<2>
@@ -546,6 +585,7 @@ namespace units {
/// cos of theta in radians
template<class Y>
+BOOST_CONSTEXPR
typename dimensionless_quantity<si::system,Y>::type
cos(const quantity<si::plane_angle,Y>& theta)
{
@@ -555,6 +595,7 @@ cos(const quantity<si::plane_angle,Y>& theta)
/// sin of theta in radians
template<class Y>
+BOOST_CONSTEXPR
typename dimensionless_quantity<si::system,Y>::type
sin(const quantity<si::plane_angle,Y>& theta)
{
@@ -564,6 +605,7 @@ sin(const quantity<si::plane_angle,Y>& theta)
/// tan of theta in radians
template<class Y>
+BOOST_CONSTEXPR
typename dimensionless_quantity<si::system,Y>::type
tan(const quantity<si::plane_angle,Y>& theta)
{
@@ -573,6 +615,7 @@ tan(const quantity<si::plane_angle,Y>& theta)
/// cos of theta in other angular units
template<class System,class Y>
+BOOST_CONSTEXPR
typename dimensionless_quantity<System,Y>::type
cos(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
{
@@ -581,6 +624,7 @@ cos(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
/// sin of theta in other angular units
template<class System,class Y>
+BOOST_CONSTEXPR
typename dimensionless_quantity<System,Y>::type
sin(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
{
@@ -589,6 +633,7 @@ sin(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
/// tan of theta in other angular units
template<class System,class Y>
+BOOST_CONSTEXPR
typename dimensionless_quantity<System,Y>::type
tan(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
{
@@ -597,6 +642,7 @@ tan(const quantity<unit<plane_angle_dimension,System>,Y>& theta)
/// acos of dimensionless quantity returning angle in same system
template<class Y,class System>
+BOOST_CONSTEXPR
quantity<unit<plane_angle_dimension, homogeneous_system<System> >,Y>
acos(const quantity<unit<dimensionless_type, homogeneous_system<System> >,Y>& val)
{
@@ -606,6 +652,7 @@ acos(const quantity<unit<dimensionless_type, homogeneous_system<System> >,Y>& va
/// acos of dimensionless quantity returning angle in radians
template<class Y>
+BOOST_CONSTEXPR
quantity<angle::radian_base_unit::unit_type,Y>
acos(const quantity<unit<dimensionless_type, heterogeneous_dimensionless_system>,Y>& val)
{
@@ -615,6 +662,7 @@ acos(const quantity<unit<dimensionless_type, heterogeneous_dimensionless_system>
/// asin of dimensionless quantity returning angle in same system
template<class Y,class System>
+BOOST_CONSTEXPR
quantity<unit<plane_angle_dimension, homogeneous_system<System> >,Y>
asin(const quantity<unit<dimensionless_type, homogeneous_system<System> >,Y>& val)
{
@@ -624,6 +672,7 @@ asin(const quantity<unit<dimensionless_type, homogeneous_system<System> >,Y>& va
/// asin of dimensionless quantity returning angle in radians
template<class Y>
+BOOST_CONSTEXPR
quantity<angle::radian_base_unit::unit_type,Y>
asin(const quantity<unit<dimensionless_type, heterogeneous_dimensionless_system>,Y>& val)
{
@@ -633,6 +682,7 @@ asin(const quantity<unit<dimensionless_type, heterogeneous_dimensionless_system>
/// atan of dimensionless quantity returning angle in same system
template<class Y,class System>
+BOOST_CONSTEXPR
quantity<unit<plane_angle_dimension, homogeneous_system<System> >,Y>
atan(const quantity<unit<dimensionless_type, homogeneous_system<System> >, Y>& val)
{
@@ -642,6 +692,7 @@ atan(const quantity<unit<dimensionless_type, homogeneous_system<System> >, Y>& v
/// atan of dimensionless quantity returning angle in radians
template<class Y>
+BOOST_CONSTEXPR
quantity<angle::radian_base_unit::unit_type,Y>
atan(const quantity<unit<dimensionless_type, heterogeneous_dimensionless_system>, Y>& val)
{
@@ -651,6 +702,7 @@ atan(const quantity<unit<dimensionless_type, heterogeneous_dimensionless_system>
/// atan2 of @c value_type returning angle in radians
template<class Y, class Dimension, class System>
+BOOST_CONSTEXPR
quantity<unit<plane_angle_dimension, homogeneous_system<System> >, Y>
atan2(const quantity<unit<Dimension, homogeneous_system<System> >, Y>& y,
const quantity<unit<Dimension, homogeneous_system<System> >, Y>& x)
@@ -661,6 +713,7 @@ atan2(const quantity<unit<Dimension, homogeneous_system<System> >, Y>& y,
/// atan2 of @c value_type returning angle in radians
template<class Y, class Dimension, class System>
+BOOST_CONSTEXPR
quantity<angle::radian_base_unit::unit_type,Y>
atan2(const quantity<unit<Dimension, heterogeneous_system<System> >, Y>& y,
const quantity<unit<Dimension, heterogeneous_system<System> >, Y>& x)
diff --git a/boost/units/config.hpp b/boost/units/config.hpp
index 694abd5aaf..64e9025ce6 100644
--- a/boost/units/config.hpp
+++ b/boost/units/config.hpp
@@ -75,7 +75,7 @@
#define BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(a, b) BOOST_STATIC_ASSERT((sizeof(a) == sizeof(b)))
#else
///INTERNAL ONLY
- #define BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(a, b) ((void)0)
+ #define BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(a, b)
#endif
#ifdef BOOST_UNITS_DOXYGEN
diff --git a/boost/units/conversion.hpp b/boost/units/conversion.hpp
index 2e5d4db6d4..f5d4a1ef2f 100644
--- a/boost/units/conversion.hpp
+++ b/boost/units/conversion.hpp
@@ -51,7 +51,7 @@ struct conversion_helper;
template<class From, class To>
struct conversion_helper
{
- static To convert(const From&);
+ static BOOST_CONSTEXPR To convert(const From&);
};
#endif
@@ -77,9 +77,9 @@ struct conversion_helper
template<> \
struct base_unit_converter<Source, reduce_unit<Destination::unit_type>::type> \
{ \
- static const bool is_defined = true; \
+ BOOST_STATIC_CONSTEXPR bool is_defined = true; \
typedef type_ type; \
- static type value() { return(value_); } \
+ static BOOST_CONSTEXPR type value() { return(value_); } \
}; \
} \
} \
@@ -103,9 +103,9 @@ struct conversion_helper
BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(Destination, typename Source::dimension_type)\
> \
{ \
- static const bool is_defined = true; \
+ BOOST_STATIC_CONSTEXPR bool is_defined = true; \
typedef type_ type; \
- static type value() { return(value_); } \
+ static BOOST_CONSTEXPR type value() { return(value_); } \
}; \
} \
} \
@@ -121,7 +121,7 @@ struct conversion_helper
template<> \
struct unscaled_get_default_conversion<unscale<Source>::type> \
{ \
- static const bool is_defined = true; \
+ BOOST_STATIC_CONSTEXPR bool is_defined = true; \
typedef Dest::unit_type type; \
}; \
} \
@@ -140,7 +140,7 @@ struct conversion_helper
template<BOOST_PP_SEQ_ENUM(Params)> \
struct unscaled_get_default_conversion<Source> \
{ \
- static const bool is_defined = true; \
+ BOOST_STATIC_CONSTEXPR bool is_defined = true; \
typedef typename Dest::unit_type type; \
}; \
} \
@@ -158,8 +158,8 @@ namespace units { \
namespace namespace_ { \
struct name_ ## _base_unit \
: base_unit<name_ ## _base_unit, unit::dimension_type, id> { \
- static const char* name() { return(name_string_); } \
- static const char* symbol() { return(symbol_string_); } \
+ static BOOST_CONSTEXPR const char* name() { return(name_string_); } \
+ static BOOST_CONSTEXPR const char* symbol() { return(symbol_string_); } \
}; \
} \
} \
@@ -170,6 +170,7 @@ BOOST_UNITS_DEFAULT_CONVERSION(namespace_::name_ ## _base_unit, unit)
/// Find the conversion factor between two units.
template<class FromUnit,class ToUnit>
inline
+BOOST_CONSTEXPR
typename one_to_double_type<
typename detail::conversion_factor_helper<FromUnit, ToUnit>::type
>::type
diff --git a/boost/units/detail/absolute_impl.hpp b/boost/units/detail/absolute_impl.hpp
index 127b33a78b..ffd8b215b8 100644
--- a/boost/units/detail/absolute_impl.hpp
+++ b/boost/units/detail/absolute_impl.hpp
@@ -32,7 +32,7 @@ struct reduce_unit<absolute<unit<D, S> > >
namespace detail {
struct undefined_affine_conversion_base {
- static const bool is_defined = false;
+ BOOST_STATIC_CONSTEXPR bool is_defined = false;
};
} // namespace detail
@@ -51,7 +51,7 @@ struct affine_conversion_impl<true, ReverseIsDefined>
{
template<class Unit1, class Unit2, class T0, class T1>
struct apply {
- static T1 value(const T0& t0)
+ static BOOST_CONSTEXPR T1 value(const T0& t0)
{
return(
t0 *
@@ -67,7 +67,7 @@ struct affine_conversion_impl<false, true>
template<class Unit1, class Unit2, class T0, class T1>
struct apply
{
- static T1 value(const T0& t0)
+ static BOOST_CONSTEXPR T1 value(const T0& t0)
{
return(
(t0 - affine_conversion_helper<typename reduce_unit<Unit2>::type, typename reduce_unit<Unit1>::type>::value()) *
@@ -84,7 +84,7 @@ struct conversion_helper<quantity<absolute<Unit1>, T1>, quantity<absolute<Unit2>
{
typedef quantity<absolute<Unit1>, T1> from_quantity_type;
typedef quantity<absolute<Unit2>, T2> to_quantity_type;
- static to_quantity_type convert(const from_quantity_type& source)
+ static BOOST_CONSTEXPR to_quantity_type convert(const from_quantity_type& source)
{
return(
to_quantity_type::from_value(
diff --git a/boost/units/detail/conversion_impl.hpp b/boost/units/detail/conversion_impl.hpp
index 8946faf5a6..f3cc19579e 100644
--- a/boost/units/detail/conversion_impl.hpp
+++ b/boost/units/detail/conversion_impl.hpp
@@ -46,12 +46,12 @@ struct call_base_unit_converter;
/// INTERNAL ONLY
struct undefined_base_unit_converter_base {
- static const bool is_defined = false;
+ BOOST_STATIC_CONSTEXPR bool is_defined = false;
};
/// INTERNAL ONLY
struct no_default_conversion {
- static const bool is_defined = false;
+ BOOST_STATIC_CONSTEXPR bool is_defined = false;
};
/// INTERNAL ONLY
@@ -110,11 +110,10 @@ struct base_unit_converter_base : undefined_base_unit_converter_base {
template<class Source>
struct base_unit_converter_base<Source, BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(Source, typename Source::dimension_type)>
{
- static const bool is_defined = true;
+ BOOST_STATIC_CONSTEXPR bool is_defined = true;
typedef one type;
- static type value() {
- one result;
- return(result);
+ static BOOST_CONSTEXPR type value() {
+ return(one());
}
};
@@ -135,7 +134,7 @@ struct do_call_base_unit_converter {
typedef typename mpl::divides<source_factor, destination_factor>::type factor;
typedef eval_scale_list<factor> eval_factor;
typedef typename multiply_typeof_helper<typename converter::type, typename eval_factor::type>::type type;
- static type value()
+ static BOOST_CONSTEXPR type value()
{
return(converter::value() * eval_factor::value());
}
@@ -172,9 +171,8 @@ struct call_base_unit_converter_base_unit_impl<false, true>
{
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() {
- one numerator;
- return(numerator / converter::value());
+ static BOOST_CONSTEXPR type value() {
+ return(one() / converter::value());
}
};
};
@@ -200,7 +198,7 @@ struct call_base_unit_converter_base_unit_impl<false, false>
>::type,
typename end::type
>::type type;
- static type value() {
+ static BOOST_CONSTEXPR type value() {
return(start::value() * conversion::value() / end::value());
}
};
@@ -220,7 +218,7 @@ struct get_default_conversion_impl
typedef typename multiply_typeof_helper<typename power_typeof_helper<new_source, exponent>::type, typename next_iteration::unit_type>::type unit_type;
typedef call_base_unit_converter<source, new_source> conversion;
typedef typename multiply_typeof_helper<typename conversion::type, typename next_iteration::type>::type type;
- static type value() {
+ static BOOST_CONSTEXPR type value() {
return(static_rational_power<exponent>(conversion::value()) * next_iteration::value());
}
};
@@ -234,9 +232,8 @@ struct get_default_conversion_impl<0>
{
typedef unit<dimensionless_type, heterogeneous_system<heterogeneous_system_impl<dimensionless_type, dimensionless_type, no_scale> > > unit_type;
typedef one type;
- static one value() {
- one result;
- return(result);
+ static BOOST_CONSTEXPR one value() {
+ return(one());
}
};
};
@@ -272,7 +269,7 @@ struct call_base_unit_converter_impl<false>
>::type,
typename impl::type
>::type type;
- static type value() {
+ static BOOST_CONSTEXPR type value() {
return(start::value() * conversion::value() / impl::value());
}
};
@@ -314,7 +311,7 @@ struct conversion_impl
typedef typename reduce_unit<units::unit<dimensions, DestinationSystem> >::type reduced_unit;
typedef detail::call_base_unit_converter<unit, reduced_unit> converter;
typedef typename multiply_typeof_helper<typename converter::type, typename next_iteration::type>::type type;
- static type value() { return(static_rational_power<typename unit_pair::value_type>(converter::value()) * next_iteration::value()); }
+ static BOOST_CONSTEXPR type value() { return(static_rational_power<typename unit_pair::value_type>(converter::value()) * next_iteration::value()); }
};
};
@@ -325,7 +322,7 @@ struct conversion_impl<0>
struct apply
{
typedef one type;
- static type value() { one result; return(result); }
+ static BOOST_CONSTEXPR type value() { return(one()); }
};
};
@@ -338,11 +335,9 @@ struct conversion_helper<quantity<Unit1, T1>, quantity<Unit2, T2> >
{
/// INTERNAL ONLY
typedef quantity<Unit2, T2> destination_type;
- static destination_type convert(const quantity<Unit1, T1>& source)
+ static BOOST_CONSTEXPR destination_type convert(const quantity<Unit1, T1>& source)
{
- Unit1 u1;
- Unit2 u2;
- return(destination_type::from_value(static_cast<T2>(source.value() * conversion_factor(u1, u2))));
+ return(destination_type::from_value(static_cast<T2>(source.value() * conversion_factor(Unit1(), Unit2()))));
}
};
@@ -365,7 +360,7 @@ struct conversion_factor_helper<unit<D, homogeneous_system<L1> >, unit<D, homoge
// homogeneous_system<L2>
//> impl;
//typedef typename impl::type type;
- //static type value()
+ //static BOOST_CONSTEXPR type value()
//{
// return(impl::value());
//}
@@ -384,7 +379,7 @@ struct conversion_factor_helper<unit<D, heterogeneous_system<L1> >, unit<D, homo
//> impl;
//typedef eval_scale_list<typename L1::scale> scale;
//typedef typename multiply_typeof_helper<typename impl::type, typename scale::type>::type type;
- //static type value()
+ //static BOOST_CONSTEXPR type value()
//{
// return(impl::value() * scale::value());
//}
@@ -406,10 +401,9 @@ struct conversion_factor_helper<unit<D, homogeneous_system<L1> >, unit<D, hetero
//> impl;
//typedef eval_scale_list<typename L2::scale> scale;
//typedef typename multiply_typeof_helper<typename impl::type, typename scale::type>::type type;
- //static type value()
+ //static BOOST_CONSTEXPR type value()
//{
- // one numerator;
- // return(numerator / (impl::value() * scale::value()));
+ // return(one() / (impl::value() * scale::value()));
//}
};
@@ -443,7 +437,7 @@ struct conversion_factor_helper<unit<D, heterogeneous_system<S1> >, unit<D, hete
typename conversion1::type,
typename divide_typeof_helper<typename scale::type, typename conversion2::type>::type
>::type type;
- static type value()
+ static BOOST_CONSTEXPR type value()
{
return(conversion1::value() * (scale::value() / conversion2::value()));
}
diff --git a/boost/units/detail/linear_algebra.hpp b/boost/units/detail/linear_algebra.hpp
index 96b27a2532..17ed34bd1b 100644
--- a/boost/units/detail/linear_algebra.hpp
+++ b/boost/units/detail/linear_algebra.hpp
@@ -598,8 +598,8 @@ struct set_insert<false> {
template<class Set, class T>
struct has_key {
- static const long size = sizeof(Set::lookup((wrap<T>*)0));
- static const bool value = (size == sizeof(set_yes));
+ BOOST_STATIC_CONSTEXPR long size = sizeof(Set::lookup((wrap<T>*)0));
+ BOOST_STATIC_CONSTEXPR bool value = (size == sizeof(set_yes));
};
template<int N>
@@ -826,7 +826,7 @@ struct normalize_units {
dimensions
>::type matrix;
typedef typename make_square_and_invert<matrix>::type type;
- static const long extra = (type::size::value) - (T::size::value);
+ BOOST_STATIC_CONSTEXPR long extra = (type::size::value) - (T::size::value);
};
// multiply_add_units computes M x V
@@ -977,7 +977,7 @@ struct is_simple_system_impl {
typename test::base_dimension_type
>
> type;
- static const bool value = (type::value);
+ BOOST_STATIC_CONSTEXPR bool value = (type::value);
};
};
@@ -1001,7 +1001,7 @@ struct is_simple_system {
typename test::base_dimension_type
>
>::type type;
- static const bool value = type::value;
+ BOOST_STATIC_CONSTEXPR bool value = type::value;
};
template<bool>
diff --git a/boost/units/detail/one.hpp b/boost/units/detail/one.hpp
index bf1cad902b..1643e6a662 100644
--- a/boost/units/detail/one.hpp
+++ b/boost/units/detail/one.hpp
@@ -17,12 +17,11 @@ namespace boost {
namespace units {
-struct one { one() {} };
+struct one { BOOST_CONSTEXPR one() {} };
// workaround for pathscale.
-inline one make_one() {
- one result;
- return(result);
+inline BOOST_CONSTEXPR one make_one() {
+ return(one());
}
template<class T>
@@ -44,21 +43,20 @@ struct multiply_typeof_helper<one, one>
};
template<class T>
-inline T operator*(const one&, const T& t)
+inline BOOST_CONSTEXPR T operator*(const one&, const T& t)
{
return(t);
}
template<class T>
-inline T operator*(const T& t, const one&)
+inline BOOST_CONSTEXPR T operator*(const T& t, const one&)
{
return(t);
}
-inline one operator*(const one&, const one&)
+inline BOOST_CONSTEXPR one operator*(const one&, const one&)
{
- one result;
- return(result);
+ return(one());
}
template<class T>
@@ -80,32 +78,31 @@ struct divide_typeof_helper<one, one>
};
template<class T>
-inline T operator/(const T& t, const one&)
+inline BOOST_CONSTEXPR T operator/(const T& t, const one&)
{
return(t);
}
template<class T>
-inline T operator/(const one&, const T& t)
+inline BOOST_CONSTEXPR T operator/(const one&, const T& t)
{
return(1/t);
}
-inline one operator/(const one&, const one&)
+inline BOOST_CONSTEXPR one operator/(const one&, const one&)
{
- one result;
- return(result);
+ return(one());
}
template<class T>
-inline bool operator>(const boost::units::one&, const T& t) {
+inline BOOST_CONSTEXPR bool operator>(const boost::units::one&, const T& t) {
return(1 > t);
}
template<class T>
-T one_to_double(const T& t) { return t; }
+BOOST_CONSTEXPR T one_to_double(const T& t) { return t; }
-inline double one_to_double(const one&) { return 1.0; }
+inline BOOST_CONSTEXPR double one_to_double(const one&) { return 1.0; }
template<class T>
struct one_to_double_type { typedef T type; };
diff --git a/boost/units/detail/ordinal.hpp b/boost/units/detail/ordinal.hpp
index b47ef67424..eaf5bde316 100644
--- a/boost/units/detail/ordinal.hpp
+++ b/boost/units/detail/ordinal.hpp
@@ -26,11 +26,11 @@ struct ordinal_tag {};
template<int N>
struct ordinal {
typedef detail::ordinal_tag tag;
- static const long value = N;
+ BOOST_STATIC_CONSTEXPR long value = N;
};
template<int N>
-const long ordinal<N>::value;
+BOOST_CONSTEXPR_OR_CONST long ordinal<N>::value;
}
diff --git a/boost/units/detail/prevent_redefinition.hpp b/boost/units/detail/prevent_redefinition.hpp
index fba969ae38..1f23575370 100644
--- a/boost/units/detail/prevent_redefinition.hpp
+++ b/boost/units/detail/prevent_redefinition.hpp
@@ -19,7 +19,7 @@ namespace units {
namespace detail {
-struct no { no() {} char dummy; };
+struct no { BOOST_CONSTEXPR no() : dummy() {} char dummy; };
struct yes { no dummy[2]; };
template<bool> struct ordinal_has_already_been_defined;
@@ -37,15 +37,17 @@ struct ordinal_has_already_been_defined<false> { typedef void type; };
/// be found by ADL
/// INTERNAL ONLY
template<class T>
+BOOST_CONSTEXPR
detail::no
boost_units_is_registered(const T&)
-{ detail::no result; return(result); }
+{ return(detail::no()); }
/// INTERNAL ONLY
template<class T>
+BOOST_CONSTEXPR
detail::no
boost_units_unit_is_registered(const T&)
-{ detail::no result; return(result); }
+{ return(detail::no()); }
} // namespace units
diff --git a/boost/units/detail/static_rational_power.hpp b/boost/units/detail/static_rational_power.hpp
index 66c9d9d04b..e8e62c757a 100644
--- a/boost/units/detail/static_rational_power.hpp
+++ b/boost/units/detail/static_rational_power.hpp
@@ -50,7 +50,7 @@ template<class R, class Y>
struct static_rational_power_impl
{
typedef typename typeof_pow_adl_barrier::typeof_pow<Y>::type type;
- static type call(const Y& y)
+ static BOOST_CONSTEXPR type call(const Y& y)
{
using std::pow;
return(pow(y, static_cast<double>(R::Numerator) / static_cast<double>(R::Denominator)));
@@ -61,10 +61,9 @@ template<class R>
struct static_rational_power_impl<R, one>
{
typedef one type;
- static one call(const one&)
+ static BOOST_CONSTEXPR one call(const one&)
{
- one result;
- return(result);
+ return(one());
}
};
@@ -72,10 +71,9 @@ template<long N>
struct static_rational_power_impl<static_rational<N, 1>, one>
{
typedef one type;
- static one call(const one&)
+ static BOOST_CONSTEXPR one call(const one&)
{
- one result;
- return(result);
+ return(one());
}
};
@@ -91,10 +89,9 @@ struct static_int_power_impl<N, true>
typedef typename multiply_typeof_helper<Y, Y>::type square_type;
typedef typename static_int_power_impl<(N >> 1)>::template apply<square_type, R> next;
typedef typename next::type type;
- static type call(const Y& y, const R& r)
+ static BOOST_CONSTEXPR type call(const Y& y, const R& r)
{
- const square_type square = y * y;
- return(next::call(square, r));
+ return(next::call(static_cast<square_type>(y * y), r));
}
};
};
@@ -109,10 +106,9 @@ struct static_int_power_impl<N, false>
typedef typename multiply_typeof_helper<Y, R>::type new_r;
typedef typename static_int_power_impl<(N >> 1)>::template apply<square_type, new_r> next;
typedef typename next::type type;
- static type call(const Y& y, const R& r)
+ static BOOST_CONSTEXPR type call(const Y& y, const R& r)
{
- const Y square = y * y;
- return(next::call(square, y * r));
+ return(next::call(static_cast<Y>(y * y), y * r));
}
};
};
@@ -124,7 +120,7 @@ struct static_int_power_impl<1, false>
struct apply
{
typedef typename multiply_typeof_helper<Y, R>::type type;
- static type call(const Y& y, const R& r)
+ static BOOST_CONSTEXPR type call(const Y& y, const R& r)
{
return(y * r);
}
@@ -138,7 +134,7 @@ struct static_int_power_impl<0, true>
struct apply
{
typedef R type;
- static R call(const Y&, const R& r)
+ static BOOST_CONSTEXPR R call(const Y&, const R& r)
{
return(r);
}
@@ -156,10 +152,9 @@ struct static_int_power_sign_impl<N, false>
{
typedef typename static_int_power_impl<N>::template apply<Y, one> impl;
typedef typename impl::type type;
- static type call(const Y& y)
+ static BOOST_CONSTEXPR type call(const Y& y)
{
- one result;
- return(impl::call(y, result));
+ return(impl::call(y, one()));
}
};
};
@@ -172,10 +167,9 @@ struct static_int_power_sign_impl<N, true>
{
typedef typename static_int_power_impl<-N>::template apply<Y, one> impl;
typedef typename divide_typeof_helper<one, typename impl::type>::type type;
- static type call(const Y& y)
+ static BOOST_CONSTEXPR type call(const Y& y)
{
- one result;
- return(result/impl::call(y, result));
+ return(one()/impl::call(y, one()));
}
};
};
@@ -185,13 +179,14 @@ struct static_rational_power_impl<static_rational<N, 1>, Y>
{
typedef typename static_int_power_sign_impl<N>::template apply<Y> impl;
typedef typename impl::type type;
- static type call(const Y& y)
+ static BOOST_CONSTEXPR type call(const Y& y)
{
return(impl::call(y));
}
};
template<class R, class Y>
+BOOST_CONSTEXPR
typename detail::static_rational_power_impl<R, Y>::type static_rational_power(const Y& y)
{
return(detail::static_rational_power_impl<R, Y>::call(y));
diff --git a/boost/units/detail/unscale.hpp b/boost/units/detail/unscale.hpp
index 08e51e96d5..e221756b11 100644
--- a/boost/units/detail/unscale.hpp
+++ b/boost/units/detail/unscale.hpp
@@ -143,7 +143,7 @@ struct eval_scale_list_impl
{
typedef typename eval_scale_list_impl<N-1>::template apply<typename Begin::next> next_iteration;
typedef typename multiply_typeof_helper<typename next_iteration::type, typename Begin::item::value_type>::type type;
- static type value()
+ static BOOST_CONSTEXPR type value()
{
return(next_iteration::value() * Begin::item::value());
}
@@ -157,10 +157,9 @@ struct eval_scale_list_impl<0>
struct apply
{
typedef one type;
- static one value()
+ static BOOST_CONSTEXPR one value()
{
- one result;
- return(result);
+ return(one());
}
};
};
@@ -225,6 +224,22 @@ struct times_impl<boost::units::scale_dim_tag, boost::units::detail::static_rati
};
};
+/// INTERNAL ONLY
+template<>
+struct divides_impl<boost::units::scale_dim_tag, boost::units::detail::static_rational_tag>
+{
+ template<class T0, class T1>
+ struct apply
+ {
+ typedef boost::units::scale_list_dim<
+ boost::units::scale<
+ (T0::base),
+ typename mpl::divides<typename T0::exponent, T1>::type
+ >
+ > type;
+ };
+};
+
} // namespace mpl
#endif
diff --git a/boost/units/io.hpp b/boost/units/io.hpp
index eda835568d..c998e2739f 100644
--- a/boost/units/io.hpp
+++ b/boost/units/io.hpp
@@ -669,17 +669,18 @@ template<class T>
struct autoprefix_norm_impl<T, true>
{
typedef double type;
- static double call(const T& arg) { return std::abs(arg); }
+ static BOOST_CONSTEXPR double call(const T& arg) { return std::abs(arg); }
};
template<class T>
struct autoprefix_norm_impl<T, false>
{
typedef one type;
- static one call(const T&) { return one(); }
+ static BOOST_CONSTEXPR one call(const T&) { return one(); }
};
template<class T>
+BOOST_CONSTEXPR
typename autoprefix_norm_impl<T>::type autoprefix_norm(const T& arg)
{
return autoprefix_norm_impl<T>::call(arg);
@@ -690,12 +691,14 @@ typename autoprefix_norm_impl<T>::type autoprefix_norm(const T& arg)
namespace detail {
template<class End, class Prev, class T, class F>
+BOOST_CONSTEXPR
bool find_matching_scale_impl(End, End, Prev, T, double, F)
{
return false;
}
template<class Begin, class End, class Prev, class T, class F>
+BOOST_CXX14_CONSTEXPR
bool find_matching_scale_impl(Begin, End end, Prev prev, T t, double x, F f)
{
if(Begin::item::value() > x) {
@@ -714,12 +717,14 @@ bool find_matching_scale_impl(Begin, End end, Prev prev, T t, double x, F f)
}
template<class End, class T, class F>
+BOOST_CONSTEXPR
bool find_matching_scale_i(End, End, T, double, F)
{
return false;
}
template<class Begin, class End, class T, class F>
+BOOST_CXX14_CONSTEXPR
bool find_matching_scale_i(Begin, End end, T t, double x, F f)
{
if(Begin::item::value() > x) {
@@ -730,6 +735,7 @@ bool find_matching_scale_i(Begin, End end, T t, double x, F f)
}
template<class Scales, class T, class F>
+BOOST_CXX14_CONSTEXPR
bool find_matching_scale(T t, double x, F f)
{
return detail::find_matching_scale_i(Scales(), dimensionless_type(), t, x, f);
@@ -976,8 +982,8 @@ void maybe_print_prefixed(std::basic_ostream<CharT, Traits>& os, const quantity<
detail::print_default(os, q)();
}
-inline mpl::true_ test_norm(double) { return mpl::true_(); }
-inline mpl::false_ test_norm(one) { return mpl::false_(); }
+inline BOOST_CONSTEXPR mpl::true_ test_norm(double) { return mpl::true_(); }
+inline BOOST_CONSTEXPR mpl::false_ test_norm(one) { return mpl::false_(); }
} // namespace detail
diff --git a/boost/units/limits.hpp b/boost/units/limits.hpp
index a8b6f73263..7886d692a0 100644
--- a/boost/units/limits.hpp
+++ b/boost/units/limits.hpp
@@ -28,46 +28,46 @@ class numeric_limits< ::boost::units::quantity<Unit, T> >
{
public:
typedef ::boost::units::quantity<Unit, T> quantity_type;
- static const bool is_specialized = std::numeric_limits<T>::is_specialized;
- static quantity_type (min)() { return(quantity_type::from_value((std::numeric_limits<T>::min)())); }
- static quantity_type (max)() { return(quantity_type::from_value((std::numeric_limits<T>::max)())); }
+ BOOST_STATIC_CONSTEXPR bool is_specialized = std::numeric_limits<T>::is_specialized;
+ static BOOST_CONSTEXPR quantity_type (min)() { return(quantity_type::from_value((std::numeric_limits<T>::min)())); }
+ static BOOST_CONSTEXPR quantity_type (max)() { return(quantity_type::from_value((std::numeric_limits<T>::max)())); }
#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
- static quantity_type (lowest)() { return(quantity_type::from_value((std::numeric_limits<T>::lowest)())); }
+ static BOOST_CONSTEXPR quantity_type (lowest)() { return(quantity_type::from_value((std::numeric_limits<T>::lowest)())); }
#endif
- static const int digits = std::numeric_limits<T>::digits;
- static const int digits10 = std::numeric_limits<T>::digits10;
+ BOOST_STATIC_CONSTEXPR int digits = std::numeric_limits<T>::digits;
+ BOOST_STATIC_CONSTEXPR int digits10 = std::numeric_limits<T>::digits10;
#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
- static const int max_digits10 = std::numeric_limits<T>::max_digits10;
+ BOOST_STATIC_CONSTEXPR int max_digits10 = std::numeric_limits<T>::max_digits10;
#endif
- static const bool is_signed = std::numeric_limits<T>::is_signed;
- static const bool is_integer = std::numeric_limits<T>::is_integer;
- static const bool is_exact = std::numeric_limits<T>::is_exact;
- static const int radix = std::numeric_limits<T>::radix;
- static quantity_type epsilon() { return(quantity_type::from_value(std::numeric_limits<T>::epsilon())); }
- static quantity_type round_error() { return(quantity_type::from_value(std::numeric_limits<T>::round_error())); }
- static const int min_exponent = std::numeric_limits<T>::min_exponent;
- static const int min_exponent10 = std::numeric_limits<T>::min_exponent10;
- static const int max_exponent = std::numeric_limits<T>::max_exponent;
- static const int max_exponent10 = std::numeric_limits<T>::max_exponent10;
- static const bool has_infinity = std::numeric_limits<T>::has_infinity;
- static const bool has_quiet_NaN = std::numeric_limits<T>::has_quiet_NaN;
- static const bool has_signaling_NaN = std::numeric_limits<T>::has_signaling_NaN;
- static const bool has_denorm_loss = std::numeric_limits<T>::has_denorm_loss;
- static quantity_type infinity() { return(quantity_type::from_value(std::numeric_limits<T>::infinity())); }
- static quantity_type quiet_NaN() { return(quantity_type::from_value(std::numeric_limits<T>::quiet_NaN())); }
- static quantity_type signaling_NaN() { return(quantity_type::from_value(std::numeric_limits<T>::signaling_NaN())); }
- static quantity_type denorm_min() { return(quantity_type::from_value(std::numeric_limits<T>::denorm_min())); }
- static const bool is_iec559 = std::numeric_limits<T>::is_iec559;
- static const bool is_bounded = std::numeric_limits<T>::is_bounded;
- static const bool is_modulo = std::numeric_limits<T>::is_modulo;
- static const bool traps = std::numeric_limits<T>::traps;
- static const bool tinyness_before = std::numeric_limits<T>::tinyness_before;
+ BOOST_STATIC_CONSTEXPR bool is_signed = std::numeric_limits<T>::is_signed;
+ BOOST_STATIC_CONSTEXPR bool is_integer = std::numeric_limits<T>::is_integer;
+ BOOST_STATIC_CONSTEXPR bool is_exact = std::numeric_limits<T>::is_exact;
+ BOOST_STATIC_CONSTEXPR int radix = std::numeric_limits<T>::radix;
+ static BOOST_CONSTEXPR quantity_type epsilon() { return(quantity_type::from_value(std::numeric_limits<T>::epsilon())); }
+ static BOOST_CONSTEXPR quantity_type round_error() { return(quantity_type::from_value(std::numeric_limits<T>::round_error())); }
+ BOOST_STATIC_CONSTEXPR int min_exponent = std::numeric_limits<T>::min_exponent;
+ BOOST_STATIC_CONSTEXPR int min_exponent10 = std::numeric_limits<T>::min_exponent10;
+ BOOST_STATIC_CONSTEXPR int max_exponent = std::numeric_limits<T>::max_exponent;
+ BOOST_STATIC_CONSTEXPR int max_exponent10 = std::numeric_limits<T>::max_exponent10;
+ BOOST_STATIC_CONSTEXPR bool has_infinity = std::numeric_limits<T>::has_infinity;
+ BOOST_STATIC_CONSTEXPR bool has_quiet_NaN = std::numeric_limits<T>::has_quiet_NaN;
+ BOOST_STATIC_CONSTEXPR bool has_signaling_NaN = std::numeric_limits<T>::has_signaling_NaN;
+ BOOST_STATIC_CONSTEXPR bool has_denorm_loss = std::numeric_limits<T>::has_denorm_loss;
+ static BOOST_CONSTEXPR quantity_type infinity() { return(quantity_type::from_value(std::numeric_limits<T>::infinity())); }
+ static BOOST_CONSTEXPR quantity_type quiet_NaN() { return(quantity_type::from_value(std::numeric_limits<T>::quiet_NaN())); }
+ static BOOST_CONSTEXPR quantity_type signaling_NaN() { return(quantity_type::from_value(std::numeric_limits<T>::signaling_NaN())); }
+ static BOOST_CONSTEXPR quantity_type denorm_min() { return(quantity_type::from_value(std::numeric_limits<T>::denorm_min())); }
+ BOOST_STATIC_CONSTEXPR bool is_iec559 = std::numeric_limits<T>::is_iec559;
+ BOOST_STATIC_CONSTEXPR bool is_bounded = std::numeric_limits<T>::is_bounded;
+ BOOST_STATIC_CONSTEXPR bool is_modulo = std::numeric_limits<T>::is_modulo;
+ BOOST_STATIC_CONSTEXPR bool traps = std::numeric_limits<T>::traps;
+ BOOST_STATIC_CONSTEXPR bool tinyness_before = std::numeric_limits<T>::tinyness_before;
#if defined(_STLP_STATIC_CONST_INIT_BUG)
- static const int has_denorm = std::numeric_limits<T>::has_denorm;
- static const int round_style = std::numeric_limits<T>::round_style;
+ BOOST_STATIC_CONSTEXPR int has_denorm = std::numeric_limits<T>::has_denorm;
+ BOOST_STATIC_CONSTEXPR int round_style = std::numeric_limits<T>::round_style;
#else
- static const float_denorm_style has_denorm = std::numeric_limits<T>::has_denorm;
- static const float_round_style round_style = std::numeric_limits<T>::round_style;
+ BOOST_STATIC_CONSTEXPR float_denorm_style has_denorm = std::numeric_limits<T>::has_denorm;
+ BOOST_STATIC_CONSTEXPR float_round_style round_style = std::numeric_limits<T>::round_style;
#endif
};
diff --git a/boost/units/operators.hpp b/boost/units/operators.hpp
index 19b8aace9b..6941aaff09 100644
--- a/boost/units/operators.hpp
+++ b/boost/units/operators.hpp
@@ -135,7 +135,7 @@ struct power_typeof_helper
/// specifies the result type
typedef detail::unspecified type;
/// Carries out the runtime calculation.
- static type value(const BaseType& base);
+ static BOOST_CONSTEXPR type value(const BaseType& base);
};
/// A helper used by @c root to take a root
@@ -152,7 +152,7 @@ struct root_typeof_helper
/// specifies the result type
typedef detail::unspecified type;
/// Carries out the runtime calculation.
- static type value(const Radicand& base);
+ static BOOST_CONSTEXPR type value(const Radicand& base);
};
#endif
diff --git a/boost/units/pow.hpp b/boost/units/pow.hpp
index 1d856a5380..a6772eec67 100644
--- a/boost/units/pow.hpp
+++ b/boost/units/pow.hpp
@@ -11,7 +11,6 @@
#ifndef BOOST_UNITS_POW_HPP
#define BOOST_UNITS_POW_HPP
-#include <boost/math_fwd.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/units/operators.hpp>
@@ -27,6 +26,7 @@ namespace units {
/// raise a value to a @c static_rational power.
template<class Rat,class Y>
+BOOST_CONSTEXPR
inline typename power_typeof_helper<Y,Rat>::type
pow(const Y& x)
{
@@ -35,6 +35,7 @@ pow(const Y& x)
/// raise a value to an integer power.
template<long N,class Y>
+BOOST_CONSTEXPR
inline typename power_typeof_helper<Y,static_rational<N> >::type
pow(const Y& x)
{
@@ -51,7 +52,7 @@ struct power_typeof_helper<T, static_rational<N,D> >
typedef detail::static_rational_power_impl<static_rational<N, D>, internal_type> impl;
typedef typename impl::type type;
- static type value(const T& x)
+ static BOOST_CONSTEXPR type value(const T& x)
{
return impl::call(x);
}
@@ -64,7 +65,7 @@ struct power_typeof_helper<float, static_rational<N,D> >
// N.B. pathscale doesn't accept inheritance for some reason.
typedef power_typeof_helper<double, static_rational<N,D> > base;
typedef typename base::type type;
- static type value(const double& x)
+ static BOOST_CONSTEXPR type value(const double& x)
{
return base::value(x);
}
@@ -74,6 +75,7 @@ struct power_typeof_helper<float, static_rational<N,D> >
/// take the @c static_rational root of a value.
template<class Rat,class Y>
+BOOST_CONSTEXPR
typename root_typeof_helper<Y,Rat>::type
root(const Y& x)
{
@@ -82,6 +84,7 @@ root(const Y& x)
/// take the integer root of a value.
template<long N,class Y>
+BOOST_CONSTEXPR
typename root_typeof_helper<Y,static_rational<N> >::type
root(const Y& x)
{
@@ -97,7 +100,7 @@ struct root_typeof_helper<T,static_rational<N,D> >
// N.B. pathscale doesn't accept inheritance for some reason.
typedef power_typeof_helper<T, static_rational<D,N> > base;
typedef typename base::type type;
- static type value(const T& x)
+ static BOOST_CONSTEXPR type value(const T& x)
{
return(base::value(x));
}
diff --git a/boost/units/quantity.hpp b/boost/units/quantity.hpp
index 7bdb78ef29..c6ae6e73d9 100644
--- a/boost/units/quantity.hpp
+++ b/boost/units/quantity.hpp
@@ -98,17 +98,17 @@ class quantity
typedef Y value_type;
typedef Unit unit_type;
- quantity() : val_()
+ BOOST_CONSTEXPR quantity() : val_()
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
- quantity(unspecified_null_pointer_constant_type) : val_()
+ BOOST_CONSTEXPR quantity(unspecified_null_pointer_constant_type) : val_()
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
- quantity(const this_type& source) : val_(source.val_)
+ BOOST_CONSTEXPR quantity(const this_type& source) : val_(source.val_)
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
@@ -124,7 +124,7 @@ class quantity
//~quantity() { }
- this_type& operator=(const this_type& source)
+ BOOST_CXX14_CONSTEXPR this_type& operator=(const this_type& source)
{
val_ = source.val_;
@@ -135,7 +135,7 @@ class quantity
/// implicit conversion between value types is allowed if allowed for value types themselves
template<class YY>
- quantity(const quantity<Unit,YY>& source,
+ BOOST_CONSTEXPR quantity(const quantity<Unit,YY>& source,
typename boost::enable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
val_(source.value())
{
@@ -144,7 +144,7 @@ class quantity
/// 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,
+ explicit BOOST_CONSTEXPR 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()))
{
@@ -155,7 +155,7 @@ class quantity
/// implicit conversion between value types is allowed if allowed for value types themselves
template<class YY>
- quantity(const quantity<Unit,YY>& source) :
+ BOOST_CONSTEXPR quantity(const quantity<Unit,YY>& source) :
val_(source.value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -166,7 +166,7 @@ class quantity
/// 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_CXX14_CONSTEXPR this_type& operator=(const quantity<Unit,YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true));
@@ -180,7 +180,7 @@ class quantity
/// 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,
+ BOOST_CONSTEXPR quantity(const quantity<Unit2,YY>& source,
typename boost::disable_if<
mpl::and_<
//is_implicitly_convertible should be undefined when the
@@ -198,7 +198,7 @@ class quantity
/// 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,
+ BOOST_CONSTEXPR quantity(const quantity<Unit2,YY>& source,
typename boost::enable_if<
mpl::and_<
typename is_implicitly_convertible<Unit2,Unit>::type,
@@ -217,7 +217,7 @@ class quantity
/// without SFINAE we can't distinguish between explicit and implicit conversions so
/// the conversion is always explicit
template<class Unit2,class YY>
- explicit quantity(const quantity<Unit2,YY>& source)
+ explicit BOOST_CONSTEXPR quantity(const quantity<Unit2,YY>& source)
: val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -228,7 +228,7 @@ class quantity
/// 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_CXX14_CONSTEXPR this_type& operator=(const quantity<Unit2,YY>& source)
{
BOOST_STATIC_ASSERT((is_implicitly_convertible<Unit2,unit_type>::value == true));
@@ -239,11 +239,11 @@ class quantity
return *this;
}
- const value_type& value() const { return val_; } ///< constant accessor to value
+ BOOST_CONSTEXPR const value_type& value() const { return val_; } ///< constant accessor to value
///< can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type
template<class Unit2, class YY>
- this_type& operator+=(const quantity<Unit2, YY>& source)
+ BOOST_CXX14_CONSTEXPR this_type& operator+=(const quantity<Unit2, YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_same<typename add_typeof_helper<Unit, Unit2>::type, Unit>::value));
val_ += source.value();
@@ -252,7 +252,7 @@ class quantity
///< 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>
- this_type& operator-=(const quantity<Unit2, YY>& source)
+ BOOST_CXX14_CONSTEXPR this_type& operator-=(const quantity<Unit2, YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_same<typename subtract_typeof_helper<Unit, Unit2>::type, Unit>::value));
val_ -= source.value();
@@ -260,7 +260,7 @@ class quantity
}
template<class Unit2, class YY>
- this_type& operator*=(const quantity<Unit2, YY>& source)
+ BOOST_CXX14_CONSTEXPR this_type& operator*=(const quantity<Unit2, YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_same<typename multiply_typeof_helper<Unit, Unit2>::type, Unit>::value));
val_ *= source.value();
@@ -268,7 +268,7 @@ class quantity
}
template<class Unit2, class YY>
- this_type& operator/=(const quantity<Unit2, YY>& source)
+ BOOST_CXX14_CONSTEXPR this_type& operator/=(const quantity<Unit2, YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_same<typename divide_typeof_helper<Unit, Unit2>::type, Unit>::value));
val_ /= source.value();
@@ -276,15 +276,15 @@ class quantity
}
///< 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& source) { val_ *= source; return *this; }
+ BOOST_CXX14_CONSTEXPR this_type& operator*=(const value_type& source) { val_ *= source; return *this; }
///< can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
- this_type& operator/=(const value_type& source) { val_ /= source; return *this; }
+ BOOST_CXX14_CONSTEXPR 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); }
+ static BOOST_CONSTEXPR this_type from_value(const value_type& val) { return this_type(val, 0); }
protected:
- explicit quantity(const value_type& val, int) : val_(val) { }
+ explicit BOOST_CONSTEXPR quantity(const value_type& val, int) : val_(val) { }
private:
value_type val_;
@@ -305,25 +305,25 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
typedef dimensionless_type dimension_type;
typedef unit<dimension_type,system_type> unit_type;
- quantity() : val_()
+ BOOST_CONSTEXPR quantity() : val_()
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
/// construction from raw @c value_type is allowed
- quantity(value_type val) : val_(val)
+ BOOST_CONSTEXPR quantity(value_type val) : val_(val)
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
- quantity(const this_type& source) : val_(source.val_)
+ BOOST_CONSTEXPR quantity(const this_type& source) : val_(source.val_)
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
}
//~quantity() { }
- this_type& operator=(const this_type& source)
+ BOOST_CXX14_CONSTEXPR this_type& operator=(const this_type& source)
{
val_ = source.val_;
@@ -334,7 +334,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between value types is allowed if allowed for value types themselves
template<class YY>
- quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
+ BOOST_CONSTEXPR 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())
{
@@ -343,7 +343,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between value types is not allowed if not allowed for value types themselves
template<class YY>
- explicit quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
+ explicit BOOST_CONSTEXPR 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()))
{
@@ -354,7 +354,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between value types is allowed if allowed for value types themselves
template<class YY>
- quantity(const quantity<unit<dimension_type,system_type>,YY>& source) :
+ BOOST_CONSTEXPR quantity(const quantity<unit<dimension_type,system_type>,YY>& source) :
val_(source.value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -365,7 +365,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// 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)
+ BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity<unit<dimension_type,system_type>,YY>& source)
{
BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
@@ -378,7 +378,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between different unit systems is allowed
template<class System2, class Y2>
- quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
+ BOOST_CONSTEXPR quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
#ifdef __SUNPRO_CC
typename boost::enable_if<
boost::mpl::and_<
@@ -399,7 +399,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between different unit systems is allowed
template<class System2, class Y2>
- explicit quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
+ explicit BOOST_CONSTEXPR quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
#ifdef __SUNPRO_CC
typename boost::enable_if<
boost::mpl::and_<
@@ -422,7 +422,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit conversion between different unit systems is allowed
template<class System2, class Y2>
- quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source) :
+ BOOST_CONSTEXPR quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source) :
val_(source.value())
{
BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -434,7 +434,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// conversion between different unit systems is explicit when
/// the units are not equivalent.
template<class System2, class Y2>
- explicit quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
+ explicit BOOST_CONSTEXPR 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())
{
@@ -445,7 +445,7 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
/// implicit assignment between different unit systems is allowed
template<class System2>
- this_type& operator=(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y>& source)
+ BOOST_CXX14_CONSTEXPR this_type& operator=(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y>& source)
{
*this = this_type(source);
@@ -455,24 +455,24 @@ class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
#endif
/// implicit conversion to @c value_type is allowed
- operator value_type() const { return val_; }
+ BOOST_CONSTEXPR operator value_type() const { return val_; }
- const value_type& value() const { return val_; } ///< constant accessor to value
+ BOOST_CONSTEXPR const value_type& value() const { return val_; } ///< constant accessor to value
///< can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type
- this_type& operator+=(const this_type& source) { val_ += source.val_; return *this; }
+ BOOST_CXX14_CONSTEXPR this_type& operator+=(const this_type& source) { val_ += source.val_; return *this; }
///< can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type
- this_type& operator-=(const this_type& source) { val_ -= source.val_; return *this; }
+ BOOST_CXX14_CONSTEXPR this_type& operator-=(const this_type& source) { val_ -= source.val_; return *this; }
///< can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type
- this_type& operator*=(const value_type& val) { val_ *= val; return *this; }
+ BOOST_CXX14_CONSTEXPR this_type& operator*=(const value_type& val) { val_ *= val; return *this; }
///< can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
- this_type& operator/=(const value_type& val) { val_ /= val; return *this; }
+ BOOST_CXX14_CONSTEXPR 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); }
+ static BOOST_CONSTEXPR this_type from_value(const value_type& val) { return this_type(val); }
private:
value_type val_;
@@ -513,7 +513,7 @@ struct quantity_cast_helper<Y,quantity<Unit,X> >
{
typedef Y type;
- type operator()(quantity<Unit,X>& source) { return const_cast<X&>(source.value()); }
+ BOOST_CONSTEXPR type operator()(quantity<Unit,X>& source) const { return const_cast<X&>(source.value()); }
};
/// specialization for casting to the value type
@@ -522,7 +522,7 @@ struct quantity_cast_helper<Y,const quantity<Unit,X> >
{
typedef Y type;
- type operator()(const quantity<Unit,X>& source) { return source.value(); }
+ BOOST_CONSTEXPR type operator()(const quantity<Unit,X>& source) const { return source.value(); }
};
} // namespace detail
@@ -530,22 +530,20 @@ struct quantity_cast_helper<Y,const quantity<Unit,X> >
/// quantity_cast provides mutating access to underlying quantity value_type
template<class X,class Y>
inline
+BOOST_CONSTEXPR
X
quantity_cast(Y& source)
{
- detail::quantity_cast_helper<X,Y> qch;
-
- return qch(source);
+ return detail::quantity_cast_helper<X,Y>()(source);
}
template<class X,class Y>
inline
+BOOST_CONSTEXPR
X
quantity_cast(const Y& source)
{
- detail::quantity_cast_helper<X,const Y> qch;
-
- return qch(source);
+ return detail::quantity_cast_helper<X,const Y>()(source);
}
/// swap quantities
@@ -863,7 +861,7 @@ struct power_typeof_helper< quantity<Unit,Y>,static_rational<N,D> >
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)
+ static BOOST_CONSTEXPR type value(const quantity<Unit,Y>& x)
{
return type::from_value(power_typeof_helper<Y,static_rational<N,D> >::value(x.value()));
}
@@ -878,7 +876,7 @@ struct root_typeof_helper< quantity<Unit,Y>,static_rational<N,D> >
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 BOOST_CONSTEXPR type value(const quantity<Unit,Y>& x)
{
return type::from_value(root_typeof_helper<Y,static_rational<N,D> >::value(x.value()));
}
@@ -890,6 +888,7 @@ template<class System,
class Dim,
class Y>
inline
+BOOST_CONSTEXPR
typename multiply_typeof_helper< unit<Dim,System>,Y >::type
operator*(const unit<Dim,System>&,const Y& rhs)
{
@@ -903,6 +902,7 @@ template<class System,
class Dim,
class Y>
inline
+BOOST_CONSTEXPR
typename divide_typeof_helper< unit<Dim,System>,Y >::type
operator/(const unit<Dim,System>&,const Y& rhs)
{
@@ -916,6 +916,7 @@ template<class System,
class Dim,
class Y>
inline
+BOOST_CONSTEXPR
typename multiply_typeof_helper< Y,unit<Dim,System> >::type
operator*(const Y& lhs,const unit<Dim,System>&)
{
@@ -929,6 +930,7 @@ template<class System,
class Dim,
class Y>
inline
+BOOST_CONSTEXPR
typename divide_typeof_helper< Y,unit<Dim,System> >::type
operator/(const Y& lhs,const unit<Dim,System>&)
{
@@ -942,6 +944,7 @@ operator/(const Y& lhs,const unit<Dim,System>&)
// class X,
// class Y>
//inline
+//BOOST_CONSTEXPR
//typename multiply_typeof_helper< quantity<Unit,X>,Y >::type
//operator*(const quantity<Unit,X>& lhs,const Y& rhs)
//{
@@ -955,6 +958,7 @@ operator/(const Y& lhs,const unit<Dim,System>&)
// class X,
// class Y>
//inline
+//BOOST_CONSTEXPR
//typename multiply_typeof_helper< X,quantity<Unit,Y> >::type
//operator*(const X& lhs,const quantity<Unit,Y>& rhs)
//{
@@ -967,6 +971,7 @@ operator/(const Y& lhs,const unit<Dim,System>&)
template<class Unit,
class X>
inline
+BOOST_CONSTEXPR
typename multiply_typeof_helper< quantity<Unit,X>,X >::type
operator*(const quantity<Unit,X>& lhs,const X& rhs)
{
@@ -979,6 +984,7 @@ operator*(const quantity<Unit,X>& lhs,const X& rhs)
template<class Unit,
class X>
inline
+BOOST_CONSTEXPR
typename multiply_typeof_helper< X,quantity<Unit,X> >::type
operator*(const X& lhs,const quantity<Unit,X>& rhs)
{
@@ -992,6 +998,7 @@ operator*(const X& lhs,const quantity<Unit,X>& rhs)
// class X,
// class Y>
//inline
+//BOOST_CONSTEXPR
//typename divide_typeof_helper< quantity<Unit,X>,Y >::type
//operator/(const quantity<Unit,X>& lhs,const Y& rhs)
//{
@@ -1005,6 +1012,7 @@ operator*(const X& lhs,const quantity<Unit,X>& rhs)
// class X,
// class Y>
//inline
+//BOOST_CONSTEXPR
//typename divide_typeof_helper< X,quantity<Unit,Y> >::type
//operator/(const X& lhs,const quantity<Unit,Y>& rhs)
//{
@@ -1017,6 +1025,7 @@ operator*(const X& lhs,const quantity<Unit,X>& rhs)
template<class Unit,
class X>
inline
+BOOST_CONSTEXPR
typename divide_typeof_helper< quantity<Unit,X>,X >::type
operator/(const quantity<Unit,X>& lhs,const X& rhs)
{
@@ -1029,6 +1038,7 @@ operator/(const quantity<Unit,X>& lhs,const X& rhs)
template<class Unit,
class X>
inline
+BOOST_CONSTEXPR
typename divide_typeof_helper< X,quantity<Unit,X> >::type
operator/(const X& lhs,const quantity<Unit,X>& rhs)
{
@@ -1043,6 +1053,7 @@ template<class System1,
class Unit2,
class Y>
inline
+BOOST_CONSTEXPR
typename multiply_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type
operator*(const unit<Dim1,System1>&,const quantity<Unit2,Y>& rhs)
{
@@ -1057,6 +1068,7 @@ template<class System1,
class Unit2,
class Y>
inline
+BOOST_CONSTEXPR
typename divide_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type
operator/(const unit<Dim1,System1>&,const quantity<Unit2,Y>& rhs)
{
@@ -1071,6 +1083,7 @@ template<class Unit1,
class Dim2,
class Y>
inline
+BOOST_CONSTEXPR
typename multiply_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type
operator*(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&)
{
@@ -1085,6 +1098,7 @@ template<class Unit1,
class Dim2,
class Y>
inline
+BOOST_CONSTEXPR
typename divide_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type
operator/(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&)
{
@@ -1095,6 +1109,7 @@ operator/(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&)
/// runtime unary plus quantity
template<class Unit,class Y>
+BOOST_CONSTEXPR
typename unary_plus_typeof_helper< quantity<Unit,Y> >::type
operator+(const quantity<Unit,Y>& val)
{
@@ -1105,6 +1120,7 @@ operator+(const quantity<Unit,Y>& val)
/// runtime unary minus quantity
template<class Unit,class Y>
+BOOST_CONSTEXPR
typename unary_minus_typeof_helper< quantity<Unit,Y> >::type
operator-(const quantity<Unit,Y>& val)
{
@@ -1119,6 +1135,7 @@ template<class Unit1,
class X,
class Y>
inline
+BOOST_CONSTEXPR
typename add_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
operator+(const quantity<Unit1,X>& lhs,
const quantity<Unit2,Y>& rhs)
@@ -1134,6 +1151,7 @@ template<class Unit1,
class X,
class Y>
inline
+BOOST_CONSTEXPR
typename subtract_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
operator-(const quantity<Unit1,X>& lhs,
const quantity<Unit2,Y>& rhs)
@@ -1149,6 +1167,7 @@ template<class Unit1,
class X,
class Y>
inline
+BOOST_CONSTEXPR
typename multiply_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
operator*(const quantity<Unit1,X>& lhs,
const quantity<Unit2,Y>& rhs)
@@ -1165,6 +1184,7 @@ template<class Unit1,
class X,
class Y>
inline
+BOOST_CONSTEXPR
typename divide_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
operator/(const quantity<Unit1,X>& lhs,
const quantity<Unit2,Y>& rhs)
@@ -1180,6 +1200,7 @@ template<class Unit,
class X,
class Y>
inline
+BOOST_CONSTEXPR
bool
operator==(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1192,6 +1213,7 @@ template<class Unit,
class X,
class Y>
inline
+BOOST_CONSTEXPR
bool
operator!=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1204,6 +1226,7 @@ template<class Unit,
class X,
class Y>
inline
+BOOST_CONSTEXPR
bool
operator<(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1216,6 +1239,7 @@ template<class Unit,
class X,
class Y>
inline
+BOOST_CONSTEXPR
bool
operator<=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1228,6 +1252,7 @@ template<class Unit,
class X,
class Y>
inline
+BOOST_CONSTEXPR
bool
operator>(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
@@ -1240,6 +1265,7 @@ template<class Unit,
class X,
class Y>
inline
+BOOST_CONSTEXPR
bool
operator>=(const quantity<Unit,X>& val1,
const quantity<Unit,Y>& val2)
diff --git a/boost/units/scale.hpp b/boost/units/scale.hpp
index 507c7fb9f3..7d64cd548e 100644
--- a/boost/units/scale.hpp
+++ b/boost/units/scale.hpp
@@ -37,10 +37,10 @@ struct scaled_base_unit;
template<long Base, class Exponent>
struct scale
{
- static const long base = Base;
+ BOOST_STATIC_CONSTEXPR long base = Base;
typedef Exponent exponent;
typedef double value_type;
- static value_type value() { return(detail::static_rational_power<Exponent>(static_cast<double>(base))); }
+ static BOOST_CONSTEXPR value_type value() { return(detail::static_rational_power<Exponent>(static_cast<double>(base))); }
// These need to be defined in specializations for
// printing to work.
// static std::string name();
@@ -48,22 +48,22 @@ struct scale
};
template<long Base, class Exponent>
-const long scale<Base, Exponent>::base;
+BOOST_CONSTEXPR_OR_CONST long scale<Base, Exponent>::base;
/// INTERNAL ONLY
template<long Base>
struct scale<Base, static_rational<0> >
{
- static const long base = Base;
+ BOOST_STATIC_CONSTEXPR long base = Base;
typedef static_rational<0> exponent;
typedef one value_type;
- static one value() { one result; return(result); }
+ static BOOST_CONSTEXPR one value() { return(one()); }
static std::string name() { return(""); }
static std::string symbol() { return(""); }
};
template<long Base>
-const long scale<Base, static_rational<0> >::base;
+BOOST_CONSTEXPR_OR_CONST long scale<Base, static_rational<0> >::base;
template<long Base,class Exponent>
std::string symbol_string(const scale<Base,Exponent>&)
@@ -83,10 +83,10 @@ std::string name_string(const scale<Base,Exponent>&)
template<> \
struct scale<base_, exponent_ > \
{ \
- static const long base = base_; \
+ BOOST_STATIC_CONSTEXPR long base = base_; \
typedef exponent_ exponent; \
typedef double value_type; \
- static value_type value() { return(val_); } \
+ static BOOST_CONSTEXPR value_type value() { return(val_); } \
static std::string name() { return(#name_); } \
static std::string symbol() { return(#symbol_); } \
}
diff --git a/boost/units/static_constant.hpp b/boost/units/static_constant.hpp
index 9026b3fde2..d3646adbda 100644
--- a/boost/units/static_constant.hpp
+++ b/boost/units/static_constant.hpp
@@ -13,9 +13,10 @@
#include <boost/units/config.hpp>
+#if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_UNITS_DOXYGEN)
/// A convenience macro that allows definition of static
/// constants in headers in an ODR-safe way.
-#define BOOST_UNITS_STATIC_CONSTANT(name, type) \
+# define BOOST_UNITS_STATIC_CONSTANT(name, type) \
template<bool b> \
struct name##_instance_t \
{ \
@@ -29,6 +30,10 @@ namespace \
\
template<bool b> \
const type name##_instance_t<b>::instance
+#else
+# define BOOST_UNITS_STATIC_CONSTANT(name, type) \
+BOOST_STATIC_CONSTEXPR type name
+#endif
/// A convenience macro for static constants with auto
/// type deduction.
diff --git a/boost/units/static_rational.hpp b/boost/units/static_rational.hpp
index 1296f06c86..6d3d818739 100644
--- a/boost/units/static_rational.hpp
+++ b/boost/units/static_rational.hpp
@@ -114,11 +114,11 @@ class static_rational
(::boost::mpl::divides<D_type, den_type>::value)
> type;
- static integer_type numerator() { return Numerator; }
- static integer_type denominator() { return Denominator; }
+ static BOOST_CONSTEXPR integer_type numerator() { return Numerator; }
+ static BOOST_CONSTEXPR integer_type denominator() { return Denominator; }
// INTERNAL ONLY
- static_rational() { }
+ BOOST_CONSTEXPR static_rational() { }
//~static_rational() { }
};
#else
@@ -127,19 +127,19 @@ class static_rational
{
private:
- static const integer_type nabs = static_abs<N>::value,
- dabs = static_abs<D>::value;
+ BOOST_STATIC_CONSTEXPR integer_type nabs = static_abs<N>::value,
+ dabs = static_abs<D>::value;
/// greatest common divisor of N and D
// need cast to signed because static_gcd returns unsigned long
- static const integer_type den =
+ BOOST_STATIC_CONSTEXPR integer_type den =
static_cast<integer_type>(boost::integer::static_gcd<nabs,dabs>::value) * ((D < 0) ? -1 : 1);
public:
// for mpl arithmetic support
typedef detail::static_rational_tag tag;
- static const integer_type Numerator = N/den,
+ BOOST_STATIC_CONSTEXPR integer_type Numerator = N/den,
Denominator = D/den;
/// INTERNAL ONLY
@@ -148,11 +148,11 @@ class static_rational
/// static_rational<N,D> reduced by GCD
typedef static_rational<Numerator,Denominator> type;
- static integer_type numerator() { return Numerator; }
- static integer_type denominator() { return Denominator; }
+ static BOOST_CONSTEXPR integer_type numerator() { return Numerator; }
+ static BOOST_CONSTEXPR integer_type denominator() { return Denominator; }
// INTERNAL ONLY
- static_rational() { }
+ BOOST_CONSTEXPR static_rational() { }
//~static_rational() { }
};
#endif
@@ -178,7 +178,7 @@ template<integer_type N> class static_rational<N,0>;
/// get decimal value of @c static_rational
template<class T,integer_type N,integer_type D>
-inline typename divide_typeof_helper<T,T>::type
+inline BOOST_CONSTEXPR typename divide_typeof_helper<T,T>::type
value(const static_rational<N,D>&)
{
return T(N)/T(D);
diff --git a/boost/units/systems/detail/constants.hpp b/boost/units/systems/detail/constants.hpp
index cf156f7072..692efa4eb6 100644
--- a/boost/units/systems/detail/constants.hpp
+++ b/boost/units/systems/detail/constants.hpp
@@ -31,22 +31,22 @@ template<class Base>
struct constant
{
typedef typename Base::value_type value_type;
- operator value_type() const { return Base().value(); }
- value_type value() const { return Base().value(); }
- value_type uncertainty() const { return Base().uncertainty(); }
- value_type lower_bound() const { return Base().lower_bound(); }
- value_type upper_bound() const { return Base().upper_bound(); }
+ BOOST_CONSTEXPR operator value_type() const { return Base().value(); }
+ BOOST_CONSTEXPR value_type value() const { return Base().value(); }
+ BOOST_CONSTEXPR value_type uncertainty() const { return Base().uncertainty(); }
+ BOOST_CONSTEXPR value_type lower_bound() const { return Base().lower_bound(); }
+ BOOST_CONSTEXPR value_type upper_bound() const { return Base().upper_bound(); }
};
template<class Base>
struct physical_constant
{
typedef typename Base::value_type value_type;
- operator value_type() const { return Base().value(); }
- value_type value() const { return Base().value(); }
- value_type uncertainty() const { return Base().uncertainty(); }
- value_type lower_bound() const { return Base().lower_bound(); }
- value_type upper_bound() const { return Base().upper_bound(); }
+ BOOST_CONSTEXPR operator value_type() const { return Base().value(); }
+ BOOST_CONSTEXPR value_type value() const { return Base().value(); }
+ BOOST_CONSTEXPR value_type uncertainty() const { return Base().uncertainty(); }
+ BOOST_CONSTEXPR value_type lower_bound() const { return Base().lower_bound(); }
+ BOOST_CONSTEXPR value_type upper_bound() const { return Base().upper_bound(); }
};
#define BOOST_UNITS_DEFINE_HELPER(name, symbol, template_name) \
@@ -64,6 +64,7 @@ struct name ## _typeof_helper<template_name<Arg1, Arg2>, constant<T> >\
}; \
\
template<class T, class Arg1, class Arg2> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<typename T::value_type, template_name<Arg1, Arg2> >::type \
operator symbol(const constant<T>& t, const template_name<Arg1, Arg2>& u)\
{ \
@@ -71,6 +72,7 @@ operator symbol(const constant<T>& t, const template_name<Arg1, Arg2>& u)\
} \
\
template<class T, class Arg1, class Arg2> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<template_name<Arg1, Arg2>, typename T::value_type>::type \
operator symbol(const template_name<Arg1, Arg2>& u, const constant<T>& t)\
{ \
@@ -97,6 +99,7 @@ struct name ## _typeof_helper<constant<T1>, constant<T2> > \
}; \
\
template<class T1, class T2> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<typename T1::value_type, typename T2::value_type>::type \
operator symbol(const constant<T1>& t, const constant<T2>& u) \
{ \
@@ -116,6 +119,7 @@ struct name ## _typeof_helper<T1, constant<T2> > \
}; \
\
template<class T1, class T2> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<typename T1::value_type, T2>::type \
operator symbol(const constant<T1>& t, const T2& u) \
{ \
@@ -123,6 +127,7 @@ operator symbol(const constant<T1>& t, const T2& u) \
} \
\
template<class T1, class T2> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<T1, typename T2::value_type>::type \
operator symbol(const T1& t, const constant<T2>& u) \
{ \
@@ -151,6 +156,7 @@ struct name ## _typeof_helper<one, constant<T2> > \
}; \
\
template<class T1> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<typename T1::value_type, one>::type \
operator symbol(const constant<T1>& t, const one& u) \
{ \
@@ -158,6 +164,7 @@ operator symbol(const constant<T1>& t, const one& u) \
} \
\
template<class T2> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<one, typename T2::value_type>::type \
operator symbol(const one& t, const constant<T2>& u) \
{ \
@@ -174,7 +181,7 @@ struct power_typeof_helper<constant<T1>, static_rational<N,D> >
{
typedef power_typeof_helper<typename T1::value_type, static_rational<N,D> > base;
typedef typename base::type type;
- static type value(const constant<T1>& arg)
+ static BOOST_CONSTEXPR type value(const constant<T1>& arg)
{
return base::value(arg.value());
}
@@ -189,6 +196,7 @@ struct name ## _typeof_helper<constant<T1> > \
}; \
\
template<class T1> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<typename T1::value_type, one>::type \
operator symbol(const constant<T1>& t, const one& u) \
{ \
@@ -196,21 +204,22 @@ operator symbol(const constant<T1>& t, const one& u) \
} \
\
template<class T2> \
+BOOST_CONSTEXPR \
typename name ## _typeof_helper<one, typename T2::value_type>::type \
operator symbol(const one& t, const constant<T2>& u) \
{ \
return(t symbol u.value()); \
}
-#define BOOST_UNITS_PHYSICAL_CONSTANT(name, type, value_, uncertainty_) \
-struct name ## _t { \
- typedef type value_type; \
- operator value_type() const { return value_; } \
- value_type value() const { return value_; } \
- value_type uncertainty() const { return uncertainty_; } \
- value_type lower_bound() const { return value_-uncertainty_; } \
- value_type upper_bound() const { return value_+uncertainty_; } \
-}; \
+#define BOOST_UNITS_PHYSICAL_CONSTANT(name, type, value_, uncertainty_) \
+struct name ## _t { \
+ typedef type value_type; \
+ BOOST_CONSTEXPR operator value_type() const { return value_; } \
+ BOOST_CONSTEXPR value_type value() const { return value_; } \
+ BOOST_CONSTEXPR value_type uncertainty() const { return uncertainty_; } \
+ BOOST_CONSTEXPR value_type lower_bound() const { return value_-uncertainty_; } \
+ BOOST_CONSTEXPR value_type upper_bound() const { return value_+uncertainty_; } \
+}; \
BOOST_UNITS_STATIC_CONSTANT(name, boost::units::constant<boost::units::physical_constant<name ## _t> >) = { }
// stream output
diff --git a/boost/units/unit.hpp b/boost/units/unit.hpp
index 7d3a8ad46f..aa4611cf7f 100644
--- a/boost/units/unit.hpp
+++ b/boost/units/unit.hpp
@@ -42,11 +42,11 @@ class unit
typedef Dim dimension_type;
typedef System system_type;
- unit() { }
- unit(const this_type&) { }
+ BOOST_CONSTEXPR unit() { }
+ BOOST_CONSTEXPR unit(const this_type&) { }
//~unit() { }
- this_type& operator=(const this_type&) { return *this; }
+ BOOST_CXX14_CONSTEXPR this_type& operator=(const this_type&) { return *this; }
// sun will ignore errors resulting from templates
// instantiated in the return type of a function.
@@ -305,7 +305,7 @@ 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>&)
+ static BOOST_CONSTEXPR type value(const unit<Dim,System>&)
{
return type();
}
@@ -317,7 +317,7 @@ 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>&)
+ static BOOST_CONSTEXPR type value(const unit<Dim,System>&)
{
return type();
}
@@ -325,6 +325,7 @@ struct root_typeof_helper<unit<Dim,System>,static_rational<N,D> >
/// unit runtime unary plus
template<class Dim,class System>
+BOOST_CONSTEXPR
typename unary_plus_typeof_helper< unit<Dim,System> >::type
operator+(const unit<Dim,System>&)
{
@@ -335,6 +336,7 @@ operator+(const unit<Dim,System>&)
/// unit runtime unary minus
template<class Dim,class System>
+BOOST_CONSTEXPR
typename unary_minus_typeof_helper< unit<Dim,System> >::type
operator-(const unit<Dim,System>&)
{
@@ -348,6 +350,7 @@ template<class Dim1,
class Dim2,
class System1,
class System2>
+BOOST_CONSTEXPR
typename add_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type
operator+(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
@@ -366,6 +369,7 @@ template<class Dim1,
class Dim2,
class System1,
class System2>
+BOOST_CONSTEXPR
typename subtract_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type
operator-(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
@@ -384,6 +388,7 @@ template<class Dim1,
class Dim2,
class System1,
class System2>
+BOOST_CONSTEXPR
typename multiply_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type
operator*(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
@@ -399,6 +404,7 @@ template<class Dim1,
class Dim2,
class System1,
class System2>
+BOOST_CONSTEXPR
typename divide_typeof_helper< unit<Dim1,System1>,
unit<Dim2,System2> >::type
operator/(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
@@ -415,6 +421,7 @@ template<class Dim1,
class System1,
class System2>
inline
+BOOST_CONSTEXPR
bool
operator==(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{
@@ -427,6 +434,7 @@ template<class Dim1,
class System1,
class System2>
inline
+BOOST_CONSTEXPR
bool
operator!=(const unit<Dim1,System1>&,const unit<Dim2,System2>&)
{