From 08c1e93fa36a49f49325a07fe91ff92c964c2b6c Mon Sep 17 00:00:00 2001 From: Chanho Park Date: Thu, 11 Dec 2014 18:55:56 +0900 Subject: Imported Upstream version 1.57.0 --- libs/units/README.md | 26 +++ libs/units/example/information.cpp | 98 +++++++++++ libs/units/example/performance.cpp | 1 + libs/units/example/systems.cpp | 28 ---- libs/units/meta/libraries.json | 16 ++ libs/units/test/Jamfile.v2 | 5 +- libs/units/test/test_dimensionless_ice1.cpp | 2 + libs/units/test/test_information_units.cpp | 242 ++++++++++++++++++++++++++++ libs/units/test/test_limits.cpp | 6 + libs/units/test/test_output.cpp | 51 +++++- 10 files changed, 444 insertions(+), 31 deletions(-) create mode 100644 libs/units/README.md create mode 100644 libs/units/example/information.cpp create mode 100644 libs/units/meta/libraries.json create mode 100644 libs/units/test/test_information_units.cpp (limited to 'libs/units') diff --git a/libs/units/README.md b/libs/units/README.md new file mode 100644 index 0000000000..555467722e --- /dev/null +++ b/libs/units/README.md @@ -0,0 +1,26 @@ +Boost.Units +=========== + +Boost.Units, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), +implements dimensional analysis in a general and extensible manner, +treating it as a generic compile-time metaprogramming problem. +With appropriate compiler optimization, no runtime execution cost is introduced, +facilitating the use of this library to provide dimension checking in performance-critical code. + +### Directories + +* **doc** - QuickBook documentation sources +* **example** - examples +* **images** - images for documention +* **include** - Interface headers +* **test** - unit tests +* **test_headers** - unit tests for self containment of headers +* **tutorial** - tutorial + +### More information + +* [Documentation](http://boost.org/libs/units) + +### License + +Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt). diff --git a/libs/units/example/information.cpp b/libs/units/example/information.cpp new file mode 100644 index 0000000000..0efc01a174 --- /dev/null +++ b/libs/units/example/information.cpp @@ -0,0 +1,98 @@ +// Boost.Units - A C++ library for zero-overhead dimensional analysis and +// unit/quantity manipulation and conversion +// +// Copyright (C) 2014 Erik Erlandson +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +//#include + +/** +\file + +\brief information.cpp + +\details +Demonstrate information unit system. + +Output: +@verbatim +bytes= 1.25e+08 B +bits= 8e+06 b +nats= 4605.17 nat +1024 bytes in a kibi-byte +8.38861e+06 bits in a mebi-byte +0.000434294 hartleys in a milli-nat +entropy in bits= 1 b +entropy in nats= 0.693147 nat +entropy in hartleys= 0.30103 Hart +entropy in shannons= 1 Sh +entropy in bytes= 0.125 B +@endverbatim +**/ + +#include +#include +using std::cout; +using std::endl; + +#include +#include +#include +namespace bu = boost::units; +using bu::quantity; +using bu::conversion_factor; + +// SI prefixes +#include +namespace si = boost::units::si; + +// information unit system +#include +using namespace bu::information; + +// Define a function for the entropy of a bernoulli trial. +// The formula is computed using natural log, so the units are in nats. +// The user provides the desired return unit, the only restriction being that it +// must be a unit of information. Conversion to the requested return unit is +// accomplished automatically by the boost::units library. +template +quantity > +bernoulli_entropy(double p, const bu::unit&) { + typedef bu::unit requested_unit; + return quantity((-(p*log(p) + (1-p)*log(1-p)))*nats); +} + +int main(int argc, char** argv) { + // a quantity of information (default in units of bytes) + quantity nbytes(1 * si::giga * bit); + cout << "bytes= " << nbytes << endl; + + // a quantity of information, stored as bits + quantity nbits(1 * si::mega * byte); + cout << "bits= " << nbits << endl; + + // a quantity of information, stored as nats + quantity nnats(2 * si::kilo * hartleys); + cout << "nats= " << nnats << endl; + + // how many bytes are in a kibi-byte? + cout << conversion_factor(kibi * byte, byte) << " bytes in a kibi-byte" << endl; + + // how many bits are in a mebi-byte? + cout << conversion_factor(mebi * byte, bit) << " bits in a mebi-byte" << endl; + + // how many hartleys are in a milli-nat? + cout << conversion_factor(si::milli * nat, hartley) << " hartleys in a milli-nat" << endl; + + // compute the entropy of a fair coin flip, in various units of information: + cout << "entropy in bits= " << bernoulli_entropy(0.5, bits) << endl; + cout << "entropy in nats= " << bernoulli_entropy(0.5, nats) << endl; + cout << "entropy in hartleys= " << bernoulli_entropy(0.5, hartleys) << endl; + cout << "entropy in shannons= " << bernoulli_entropy(0.5, shannons) << endl; + cout << "entropy in bytes= " << bernoulli_entropy(0.5, bytes) << endl; + + return 0; +} diff --git a/libs/units/example/performance.cpp b/libs/units/example/performance.cpp index 0dce3cef78..3407c13714 100644 --- a/libs/units/example/performance.cpp +++ b/libs/units/example/performance.cpp @@ -55,6 +55,7 @@ solving y' = 1 - x + 4 * y with quantity: 1.84 seconds #include #include #include +#include enum { tile_block_size = 24 diff --git a/libs/units/example/systems.cpp b/libs/units/example/systems.cpp index 9c34804198..877b2fa768 100644 --- a/libs/units/example/systems.cpp +++ b/libs/units/example/systems.cpp @@ -229,34 +229,6 @@ BOOST_UNITS_DEFINE_SINGLE_UNIT_SYSTEM(us,pint,volume) BOOST_UNITS_DEFINE_SINGLE_UNIT_SYSTEM(us,quart,volume) BOOST_UNITS_DEFINE_SINGLE_UNIT_SYSTEM(us,gallon,volume) -#ifdef __GNUC__ -#include -#endif - -inline std::string demangle(const char* name) -{ - #ifdef __GNUC__ - // need to demangle C++ symbols - char* realname; - std::size_t len; - int stat; - - realname = abi::__cxa_demangle(name,NULL,&len,&stat); - - if (realname != NULL) - { - const std::string out(realname); - free(realname); - - return out; - } - - return std::string("demangle :: error - unable to demangle specified symbol"); - #else - return name; - #endif -} - int main(void) { using namespace boost::units; diff --git a/libs/units/meta/libraries.json b/libs/units/meta/libraries.json new file mode 100644 index 0000000000..4e8bdb9adf --- /dev/null +++ b/libs/units/meta/libraries.json @@ -0,0 +1,16 @@ +{ + "key": "units", + "name": "Units", + "authors": [ + "Matthias Schabel", + "Steven Watanabe" + ], + "description": "Zero-overhead dimensional analysis and unit/quantity manipulation and conversion.", + "category": [ + "Domain" + ], + "maintainers": [ + "Jürgen Hunold ", + "Steven Watanabe " + ] +} diff --git a/libs/units/test/Jamfile.v2 b/libs/units/test/Jamfile.v2 index c75a4edb21..8913e2b6f1 100644 --- a/libs/units/test/Jamfile.v2 +++ b/libs/units/test/Jamfile.v2 @@ -16,7 +16,7 @@ warning-compilers = project boost/units/test : requirements - /boost//headers + /boost//headers ../../.. msvc:on $(warning-compilers):$(warning-options) @@ -52,8 +52,9 @@ run test_custom_unit.cpp ; run test_scaled_conversion.cpp ; run test_lambda.cpp ; run test_scaled_unit.cpp test_framework ; -run test_output.cpp test_framework /boost//regex ; +run test_output.cpp test_framework /boost//regex : : : always_show_run_output ; run test_trig.cpp test_framework ; +run test_information_units.cpp test_framework ; compile-fail fail_implicit_conversion.cpp ; compile-fail fail_quantity_construct.cpp ; diff --git a/libs/units/test/test_dimensionless_ice1.cpp b/libs/units/test/test_dimensionless_ice1.cpp index 469cb4cf22..8fb9867833 100644 --- a/libs/units/test/test_dimensionless_ice1.cpp +++ b/libs/units/test/test_dimensionless_ice1.cpp @@ -8,12 +8,14 @@ // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) +#include #include #include void foo() { boost::units::quantity d = boost::units::quantity< boost::units::si::dimensionless >(); + boost::ignore_unused(d); } #include diff --git a/libs/units/test/test_information_units.cpp b/libs/units/test/test_information_units.cpp new file mode 100644 index 0000000000..6bb1ab5960 --- /dev/null +++ b/libs/units/test/test_information_units.cpp @@ -0,0 +1,242 @@ +// Boost.Units - A C++ library for zero-overhead dimensional analysis and +// unit/quantity manipulation and conversion +// +// Copyright (C) 2014 Erik Erlandson +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include +#include + +#include +#include +#include + +#include +#include + +// All information systems definitions +#include + +using std::cout; +using std::cerr; +using std::endl; +using std::stringstream; + +namespace bu = boost::units; +namespace si = boost::units::si; + +using bu::quantity; + +using bu::information::bit_base_unit; +using bu::information::byte_base_unit; +using bu::information::nat_base_unit; +using bu::information::hartley_base_unit; +using bu::information::shannon_base_unit; + + +#define BOOST_TEST_MAIN +#include + + +#include + +const double close_fraction = 0.0000001; + +// checks that cf(u2,u1) == expected +// also checks invariant property that cf(u2,u1) * cf(u1,u2) == 1 +#define CHECK_DIRECT_CF(u1, u2, expected) \ + BOOST_CHECK_CLOSE_FRACTION(bu::conversion_factor((u2), (u1)), (expected), close_fraction); \ + BOOST_CHECK_CLOSE_FRACTION(bu::conversion_factor((u2), (u1)) * bu::conversion_factor((u1), (u2)), 1.0, close_fraction); + +// check transitive conversion factors +// invariant: cf(u1,u3) = cf(u1,u2)*cf(u2,u3) +#define CHECK_TRANSITIVE_CF(u1, u2, u3) { \ + double cf12 = bu::conversion_factor((u2), (u1)) ; \ + double cf23 = bu::conversion_factor((u3), (u2)) ; \ + double cf13 = bu::conversion_factor((u3), (u1)) ; \ + BOOST_CHECK_CLOSE_FRACTION(cf13, cf12*cf23, close_fraction); \ + double cf32 = bu::conversion_factor((u2), (u3)) ; \ + double cf21 = bu::conversion_factor((u1), (u2)) ; \ + double cf31 = bu::conversion_factor((u1), (u3)) ; \ + BOOST_CHECK_CLOSE_FRACTION(cf31, cf32*cf21, close_fraction); \ +} + + +BOOST_AUTO_TEST_CASE(test_cf_bit_byte) { + CHECK_DIRECT_CF(bit_base_unit::unit_type(), byte_base_unit::unit_type(), 8.0); +} + +BOOST_AUTO_TEST_CASE(test_cf_bit_nat) { + CHECK_DIRECT_CF(bit_base_unit::unit_type(), nat_base_unit::unit_type(), 1.442695040888964); +} + +BOOST_AUTO_TEST_CASE(test_cf_bit_hartley) { + CHECK_DIRECT_CF(bit_base_unit::unit_type(), hartley_base_unit::unit_type(), 3.321928094887363); +} + +BOOST_AUTO_TEST_CASE(test_cf_bit_shannon) { + CHECK_DIRECT_CF(bit_base_unit::unit_type(), shannon_base_unit::unit_type(), 1.0); +} + +///////////////////////////////////////////////////////////////////////////////////// +// spot-check that these are automatically transitive, thru central "hub unit" bit: +// basic pattern is to test invariant property: cf(c,a) = cf(c,b)*cf(b,a) + +BOOST_AUTO_TEST_CASE(test_transitive_byte_nat) { + CHECK_TRANSITIVE_CF(byte_base_unit::unit_type(), bit_base_unit::unit_type(), nat_base_unit::unit_type()); +} +BOOST_AUTO_TEST_CASE(test_transitive_nat_hartley) { + CHECK_TRANSITIVE_CF(nat_base_unit::unit_type(), bit_base_unit::unit_type(), hartley_base_unit::unit_type()); +} +BOOST_AUTO_TEST_CASE(test_transitive_hartley_shannon) { + CHECK_TRANSITIVE_CF(hartley_base_unit::unit_type(), bit_base_unit::unit_type(), shannon_base_unit::unit_type()); +} +BOOST_AUTO_TEST_CASE(test_transitive_shannon_byte) { + CHECK_TRANSITIVE_CF(shannon_base_unit::unit_type(), bit_base_unit::unit_type(), byte_base_unit::unit_type()); +} + +// test transitive factors, none of which are bit, just for good measure +BOOST_AUTO_TEST_CASE(test_transitive_byte_nat_hartley) { + CHECK_TRANSITIVE_CF(byte_base_unit::unit_type(), nat_base_unit::unit_type(), hartley_base_unit::unit_type()); +} + +BOOST_AUTO_TEST_CASE(test_byte_quantity_is_default) { + using namespace bu::information; + quantity qd(2 * byte); + BOOST_CHECK_EQUAL(qd.value(), double(2)); + quantity ql(2 * byte); + BOOST_CHECK_EQUAL(ql.value(), long(2)); +} + +BOOST_AUTO_TEST_CASE(test_byte_quantity_explicit) { + using namespace bu::information; + quantity qd(2 * byte); + BOOST_CHECK_EQUAL(qd.value(), double(2)); + quantity ql(2 * byte); + BOOST_CHECK_EQUAL(ql.value(), long(2)); +} + +BOOST_AUTO_TEST_CASE(test_bit_quantity) { + using namespace bu::information; + quantity qd(2 * bit); + BOOST_CHECK_EQUAL(qd.value(), double(2)); + quantity ql(2 * bit); + BOOST_CHECK_EQUAL(ql.value(), long(2)); +} + +BOOST_AUTO_TEST_CASE(test_nat_quantity) { + using namespace bu::information; + quantity qd(2 * nat); + BOOST_CHECK_EQUAL(qd.value(), double(2)); + quantity ql(2 * nat); + BOOST_CHECK_EQUAL(ql.value(), long(2)); +} + +BOOST_AUTO_TEST_CASE(test_hartley_quantity) { + using namespace bu::information; + quantity qd(2 * hartley); + BOOST_CHECK_EQUAL(qd.value(), double(2)); + quantity ql(2 * hartley); + BOOST_CHECK_EQUAL(ql.value(), long(2)); +} + +BOOST_AUTO_TEST_CASE(test_shannon_quantity) { + using namespace bu::information; + quantity qd(2 * shannon); + BOOST_CHECK_EQUAL(qd.value(), double(2)); + quantity ql(2 * shannon); + BOOST_CHECK_EQUAL(ql.value(), long(2)); +} + +BOOST_AUTO_TEST_CASE(test_mixed_hu) { + using namespace bu::information; + const double cf = 0.001; + BOOST_CHECK_CLOSE_FRACTION((quantity(1.0 * bits)).value(), 1.0, cf); + BOOST_CHECK_CLOSE_FRACTION((quantity(1.0 * bits)).value(), 1.0/8.0, cf); + BOOST_CHECK_CLOSE_FRACTION((quantity(1.0 * bits)).value(), 0.69315, cf); + BOOST_CHECK_CLOSE_FRACTION((quantity(1.0 * bits)).value(), 0.30102, cf); + BOOST_CHECK_CLOSE_FRACTION((quantity(1.0 * bits)).value(), 1.0, cf); +} + +BOOST_AUTO_TEST_CASE(test_info_prefixes) { + using namespace bu::information; + quantity q10(1LL * kibi * byte); + BOOST_CHECK_EQUAL(q10.value(), 1024LL); + + quantity q20(1LL * mebi * byte); + BOOST_CHECK_EQUAL(q20.value(), 1048576LL); + + quantity q30(1LL * gibi * byte); + BOOST_CHECK_EQUAL(q30.value(), 1073741824LL); + + quantity q40(1LL * tebi * byte); + BOOST_CHECK_EQUAL(q40.value(), 1099511627776LL); + + quantity q50(1LL * pebi * byte); + BOOST_CHECK_EQUAL(q50.value(), 1125899906842624LL); + + quantity q60(1LL * exbi * byte); + BOOST_CHECK_EQUAL(q60.value(), 1152921504606846976LL); + + using boost::multiprecision::int128_t; + + quantity q70(1LL * zebi * byte); + BOOST_CHECK_EQUAL(q70.value(), int128_t("1180591620717411303424")); + + quantity q80(1LL * yobi * byte); + BOOST_CHECK_EQUAL(q80.value(), int128_t("1208925819614629174706176")); + + // sanity check: si prefixes should also operate + quantity q1e3(1LL * si::kilo * byte); + BOOST_CHECK_EQUAL(q1e3.value(), 1000LL); + + quantity q1e6(1LL * si::mega * byte); + BOOST_CHECK_EQUAL(q1e6.value(), 1000000LL); +} + +BOOST_AUTO_TEST_CASE(test_unit_constant_io) { + using namespace bu::information; + + std::stringstream ss; + ss << bu::symbol_format << bytes; + BOOST_CHECK_EQUAL(ss.str(), "B"); + + ss.str(""); + ss << bu::name_format << bytes; + BOOST_CHECK_EQUAL(ss.str(), "byte"); + + ss.str(""); + ss << bu::symbol_format << bits; + BOOST_CHECK_EQUAL(ss.str(), "b"); + + ss.str(""); + ss << bu::name_format << bits; + BOOST_CHECK_EQUAL(ss.str(), "bit"); + + ss.str(""); + ss << bu::symbol_format << nats; + BOOST_CHECK_EQUAL(ss.str(), "nat"); + + ss.str(""); + ss << bu::name_format << nats; + BOOST_CHECK_EQUAL(ss.str(), "nat"); + + ss.str(""); + ss << bu::symbol_format << hartleys; + BOOST_CHECK_EQUAL(ss.str(), "Hart"); + + ss.str(""); + ss << bu::name_format << hartleys; + BOOST_CHECK_EQUAL(ss.str(), "hartley"); + + ss.str(""); + ss << bu::symbol_format << shannons; + BOOST_CHECK_EQUAL(ss.str(), "Sh"); + + ss.str(""); + ss << bu::name_format << shannons; + BOOST_CHECK_EQUAL(ss.str(), "shannon"); +} diff --git a/libs/units/test/test_limits.cpp b/libs/units/test/test_limits.cpp index 458feefdbd..6057cf94d3 100644 --- a/libs/units/test/test_limits.cpp +++ b/libs/units/test/test_limits.cpp @@ -80,10 +80,16 @@ void do_check() { CHECK_FUNCTION(round_error); CHECK_FUNCTION(infinity); CHECK_FUNCTION(denorm_min); + #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS + CHECK_FUNCTION(lowest); + #endif CHECK_CONSTANT(is_specialized); CHECK_CONSTANT(digits); CHECK_CONSTANT(digits10); + #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS + CHECK_CONSTANT(max_digits10); + #endif CHECK_CONSTANT(is_signed); CHECK_CONSTANT(is_integer); CHECK_CONSTANT(is_exact); diff --git a/libs/units/test/test_output.cpp b/libs/units/test/test_output.cpp index 95c3a21ce7..7404bc60b4 100644 --- a/libs/units/test/test_output.cpp +++ b/libs/units/test/test_output.cpp @@ -35,6 +35,7 @@ Tests for output from various units, name, symbol and raw formats, and automatic #include +#include #include #include #include @@ -132,6 +133,18 @@ typedef boost::units::make_scaled_unit::infinity()*meter_base_unit::unit_type(), "(1\\.#INF|inf|INF) meter"); BOOST_UNITS_TEST_OUTPUT_REGEX(-std::numeric_limits::infinity()*meter_base_unit::unit_type(), "-(1\\.#INF|inf|INF) meter"); BOOST_UNITS_TEST_OUTPUT_REGEX(std::numeric_limits::quiet_NaN()*meter_base_unit::unit_type(), "(1\\.#QNAN|nan|NaNQ) meter"); - BOOST_UNITS_TEST_OUTPUT_REGEX(-std::numeric_limits::quiet_NaN()*meter_base_unit::unit_type(), "-?(1\\.#IND|nan|NaNQ) meter"); + BOOST_UNITS_TEST_OUTPUT_REGEX(-std::numeric_limits::quiet_NaN()*meter_base_unit::unit_type(), "-?(1\\.#IND|nan|nan\\(ind\\)|NaNQ) meter"); BOOST_UNITS_TEST_OUTPUT(1.5*velocity(), "1.5 meter second^-1"); BOOST_UNITS_TEST_OUTPUT(1.5*scaled_length(), "1.5 kilometer"); @@ -395,6 +415,8 @@ BOOST_AUTO_TEST_CASE(test_output_auto_binary_prefixed_quantity_symbol) BOOST_UNITS_TEST_OUTPUT(pow(2., 40) * byte_base_unit::unit_type(), "1 Tib"); BOOST_UNITS_TEST_OUTPUT(pow(2., 50) * byte_base_unit::unit_type(), "1 Pib"); BOOST_UNITS_TEST_OUTPUT(pow(2., 60) * byte_base_unit::unit_type(), "1 Eib"); + BOOST_UNITS_TEST_OUTPUT(pow(2., 70) * byte_base_unit::unit_type(), "1 Zib"); + BOOST_UNITS_TEST_OUTPUT(pow(2., 80) * byte_base_unit::unit_type(), "1 Yib"); BOOST_UNITS_TEST_OUTPUT(42, "42"); // integer scalar. BOOST_UNITS_TEST_OUTPUT(-42, "-42"); // integer scalar. BOOST_UNITS_TEST_OUTPUT(1567, "1567"); // scalars are *not* autoprefixed. @@ -408,12 +430,16 @@ BOOST_AUTO_TEST_CASE(test_output_auto_binary_prefixed_quantity_name) // 1998 the International Electrotechnical Commission (IEC) approved // IEC 60027-2, Second edition, 2000-11, Letter symbols to be used in electrical technology // - Part 2: Telecommunications and electronics. + // IEC 80000-13:2008, Quantities and units + // – Part 13: Information science and technology #define FORMATTERS << boost::units::name_format << boost::units::binary_prefix BOOST_UNITS_TEST_OUTPUT(2048 * byte_base_unit::unit_type(), "2 kibibyte"); BOOST_UNITS_TEST_OUTPUT(pow(2., 32) *byte_base_unit::unit_type(), "4 gibibyte"); BOOST_UNITS_TEST_OUTPUT(pow(2., 41) *byte_base_unit::unit_type(), "2 tebibyte"); // http://en.wikipedia.org/wiki/Tebibyte BOOST_UNITS_TEST_OUTPUT(pow(2., 50) *byte_base_unit::unit_type(), "1 pebibyte"); BOOST_UNITS_TEST_OUTPUT(pow(2., 60) *byte_base_unit::unit_type(), "1 exbibyte"); + BOOST_UNITS_TEST_OUTPUT(pow(2., 70) *byte_base_unit::unit_type(), "1 zebibyte"); + BOOST_UNITS_TEST_OUTPUT(pow(2., 80) *byte_base_unit::unit_type(), "1 yobibyte"); BOOST_UNITS_TEST_OUTPUT(2048, "2048"); // scalars are *not* autoprefixed. BOOST_UNITS_TEST_OUTPUT(-4096, "-4096"); // scalars are *not* autoprefixed. #undef FORMATTERS @@ -448,3 +474,26 @@ BOOST_AUTO_TEST_CASE(test_output_auto_binary_prefixed_quantity_symbol_duplicate) BOOST_UNITS_TEST_OUTPUT(2048 * byte_base_unit::unit_type(), "2 Kib"); #undef FORMATTERS } + +BOOST_AUTO_TEST_CASE(test_output_typename_format) +{ // Displays typename formatting result. The test doesn't check the formatting result + // and thus doesn't fail because the formatting result is platform-dependent. +#define FORMATTERS << boost::units::typename_format + BOOST_UNITS_TEST_OUTPUT_DISPLAY(meter_base_unit::unit_type()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(velocity()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_length()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_velocity1()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(millisecond_base_unit::unit_type()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_time()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_velocity2()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(area()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_area()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(double_scaled_length()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(double_scaled_length2()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(custom1()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(custom2()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_custom1()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(scaled_custom2()); + BOOST_UNITS_TEST_OUTPUT_DISPLAY(boost::units::absolute()); +#undef FORMATTERS +} -- cgit v1.2.3