boost/units/scale.hpp

0001 // Boost.Units - A C++ library for zero-overhead dimensional analysis and
0002 // unit/quantity manipulation and conversion
0003 //
0004 // Copyright (C) 2003-2008 Matthias Christian Schabel
0005 // Copyright (C) 2007-2008 Steven Watanabe
0006 //
0007 // Distributed under the Boost Software License, Version 1.0. (See
0008 // accompanying file LICENSE_1_0.txt or copy at
0009 // http://www.boost.org/LICENSE_1_0.txt)
0010
0011 #ifndef BOOST_UNITS_SCALE_HPP_INCLUDED
0012 #define BOOST_UNITS_SCALE_HPP_INCLUDED
0013
0014 ///
0015 /// \file
0016 /// \brief 10^3 Engineering & 2^10 binary scaling factors for autoprefixing.
0017 /// \details
0018 ///
0019
0020 #include <string>
0021
0022 #include <boost/units/config.hpp>
0023 #include <boost/units/static_rational.hpp>
0024 #include <boost/units/units_fwd.hpp>
0025 #include <boost/units/detail/one.hpp>
0026 #include <boost/units/detail/static_rational_power.hpp>
0027
0028 namespace boost {
0029
0030 namespace units {
0031
0032 template<class S, class Scale>
0033 struct scaled_base_unit;
0034
0035 /// class representing a scaling factor such as 10^3
0036 /// The exponent must be a static rational.
0037 template<long Base, class Exponent>
0038 struct scale
0039 {
0040     BOOST_STATIC_CONSTEXPR long base = Base;
0041     typedef Exponent exponent;
0042     typedef double value_type;
0043     static BOOST_CONSTEXPR value_type value() { return(detail::static_rational_power<Exponent>(static_cast<double>(base))); }
0044     // These need to be defined in specializations for
0045     // printing to work.
0046     // static std::string name();
0047     // static std::string symbol();
0048 };
0049
0050 template<long Base, class Exponent>
0051 BOOST_CONSTEXPR_OR_CONST long scale<Base, Exponent>::base;
0052
0053 /// INTERNAL ONLY
0054 template<long Base>
0055 struct scale<Base, static_rational<0> >
0056 {
0057     BOOST_STATIC_CONSTEXPR long base = Base;
0058     typedef static_rational<0> exponent;
0059     typedef one value_type;
0060     static BOOST_CONSTEXPR one value() { return(one()); }
0061     static std::string name() { return(""); }
0062     static std::string symbol() { return(""); }
0063 };
0064
0065 template<long Base>
0066 BOOST_CONSTEXPR_OR_CONST long scale<Base, static_rational<0> >::base;
0067
0068 template<long Base,class Exponent>
0069 std::string symbol_string(const scale<Base,Exponent>&)
0070 {
0071     return scale<Base,Exponent>::symbol();
0072 }
0073
0074 template<long Base,class Exponent>
0075 std::string name_string(const scale<Base,Exponent>&)
0076 {
0077     return scale<Base,Exponent>::name();
0078 }
0079
0080 #ifndef BOOST_UNITS_DOXYGEN
0081
0082 #define BOOST_UNITS_SCALE_SPECIALIZATION(base_,exponent_,val_,name_,symbol_) \
0083 template<>                                                                   \
0084 struct scale<base_, exponent_ >                                              \
0085 {                                                                            \
0086     BOOST_STATIC_CONSTEXPR long base = base_;                                \
0087     typedef exponent_ exponent;                                              \
0088     typedef double value_type;                                               \
0089     static BOOST_CONSTEXPR value_type value()   { return(val_); }            \
0090     static std::string name()   { return(#name_); }                          \
0091     static std::string symbol() { return(#symbol_); }                        \
0092 }
0093
0094 #define BOOST_UNITS_SCALE_DEF(exponent_,value_,name_,symbol_)                 \
0095 BOOST_UNITS_SCALE_SPECIALIZATION(10,static_rational<exponent_>,value_, name_, symbol_)
0096
0097 BOOST_UNITS_SCALE_DEF(-24, 1e-24, yocto, y);
0098 BOOST_UNITS_SCALE_DEF(-21, 1e-21, zepto, z);
0099 BOOST_UNITS_SCALE_DEF(-18, 1e-18, atto, a);
0100 BOOST_UNITS_SCALE_DEF(-15, 1e-15, femto, f);
0101 BOOST_UNITS_SCALE_DEF(-12, 1e-12, pico, p);
0102 BOOST_UNITS_SCALE_DEF(-9, 1e-9, nano, n);
0103 BOOST_UNITS_SCALE_DEF(-6, 1e-6, micro, u);
0104 BOOST_UNITS_SCALE_DEF(-3, 1e-3, milli, m);
0105 BOOST_UNITS_SCALE_DEF(-2, 1e-2, centi, c);
0106 BOOST_UNITS_SCALE_DEF(-1, 1e-1, deci, d);
0107
0108 BOOST_UNITS_SCALE_DEF(1, 1e1, deka, da);
0109 BOOST_UNITS_SCALE_DEF(2, 1e2, hecto, h);
0110 BOOST_UNITS_SCALE_DEF(3, 1e3, kilo, k);
0111 BOOST_UNITS_SCALE_DEF(6, 1e6, mega, M);
0112 BOOST_UNITS_SCALE_DEF(9, 1e9, giga, G);
0113 BOOST_UNITS_SCALE_DEF(12, 1e12, tera, T);
0114 BOOST_UNITS_SCALE_DEF(15, 1e15, peta, P);
0115 BOOST_UNITS_SCALE_DEF(18, 1e18, exa, E);
0116 BOOST_UNITS_SCALE_DEF(21, 1e21, zetta, Z);
0117 BOOST_UNITS_SCALE_DEF(24, 1e24, yotta, Y);
0118
0119 BOOST_UNITS_SCALE_SPECIALIZATION(2, static_rational<10>, 1024.0, kibi, Ki);
0120 BOOST_UNITS_SCALE_SPECIALIZATION(2, static_rational<20>, 1048576.0, mebi, Mi);
0121 BOOST_UNITS_SCALE_SPECIALIZATION(2, static_rational<30>, 1073741824.0, gibi, Gi);
0122 BOOST_UNITS_SCALE_SPECIALIZATION(2, static_rational<40>, 1099511627776.0, tebi, Ti);
0123 BOOST_UNITS_SCALE_SPECIALIZATION(2, static_rational<50>, 1125899906842624.0, pebi, Pi);
0124 BOOST_UNITS_SCALE_SPECIALIZATION(2, static_rational<60>, 1152921504606846976.0, exbi, Ei);
0125 BOOST_UNITS_SCALE_SPECIALIZATION(2, static_rational<70>, 1180591620717411303424.0, zebi, Zi);
0126 BOOST_UNITS_SCALE_SPECIALIZATION(2, static_rational<80>, 1208925819614629174706176.0, yobi, Yi);
0127
0128 #undef BOOST_UNITS_SCALE_DEF
0129 #undef BOOST_UNITS_SCALE_SPECIALIZATION
0130
0131 #endif
0132
0133 } // namespace units
0134
0135 } // namespace boost
0136
0137 #if BOOST_UNITS_HAS_BOOST_TYPEOF
0138
0139 #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
0140
0141 BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::scale, (long)(class))
0142
0143 #endif
0144
0145 #endif