├── .gitattributes ├── .travis.yml ├── CMakeLists.txt ├── README.md ├── appveyor.yml ├── boost.css ├── build.jam ├── covscan.sh ├── doc ├── Jamfile.v2 └── units.qbk ├── example ├── Jamfile.v2 ├── autoprefixes.cpp ├── complex.cpp ├── composite_output.cpp ├── conversion.cpp ├── conversion_factor.cpp ├── dimension.cpp ├── heterogeneous_unit.cpp ├── information.cpp ├── kitchen_sink.cpp ├── lambda.cpp ├── measurement.hpp ├── non_base_dimension.cpp ├── performance.cpp ├── quantity.cpp ├── quaternion.cpp ├── radar_beam_height.cpp ├── runtime_conversion_factor.cpp ├── runtime_unit.cpp ├── runtime_unit_input.txt ├── systems.cpp ├── temperature.cpp ├── test_system.hpp ├── tutorial.cpp └── unit.cpp ├── images ├── form_0.png ├── form_1.png ├── form_10.png ├── form_11.png ├── form_12.png ├── form_13.png ├── form_14.png ├── form_15.png ├── form_2.png ├── form_3.png ├── form_4.png ├── form_5.png ├── form_6.png ├── form_7.png ├── form_8.png └── form_9.png ├── include └── boost │ └── units │ ├── absolute.hpp │ ├── base_dimension.hpp │ ├── base_unit.hpp │ ├── base_units │ ├── angle │ │ ├── arcminute.hpp │ │ ├── arcsecond.hpp │ │ ├── degree.hpp │ │ ├── gradian.hpp │ │ ├── radian.hpp │ │ ├── revolution.hpp │ │ └── steradian.hpp │ ├── astronomical │ │ ├── astronomical_unit.hpp │ │ ├── light_day.hpp │ │ ├── light_hour.hpp │ │ ├── light_minute.hpp │ │ ├── light_second.hpp │ │ ├── light_year.hpp │ │ └── parsec.hpp │ ├── cgs │ │ ├── biot.hpp │ │ ├── centimeter.hpp │ │ └── gram.hpp │ ├── imperial │ │ ├── conversions.hpp │ │ ├── drachm.hpp │ │ ├── fluid_ounce.hpp │ │ ├── foot.hpp │ │ ├── furlong.hpp │ │ ├── gallon.hpp │ │ ├── gill.hpp │ │ ├── grain.hpp │ │ ├── hundredweight.hpp │ │ ├── inch.hpp │ │ ├── league.hpp │ │ ├── mile.hpp │ │ ├── ounce.hpp │ │ ├── pint.hpp │ │ ├── pound.hpp │ │ ├── quart.hpp │ │ ├── quarter.hpp │ │ ├── stone.hpp │ │ ├── thou.hpp │ │ ├── ton.hpp │ │ └── yard.hpp │ ├── information │ │ ├── bit.hpp │ │ ├── byte.hpp │ │ ├── hartley.hpp │ │ ├── nat.hpp │ │ └── shannon.hpp │ ├── metric │ │ ├── angstrom.hpp │ │ ├── are.hpp │ │ ├── atmosphere.hpp │ │ ├── bar.hpp │ │ ├── barn.hpp │ │ ├── day.hpp │ │ ├── fermi.hpp │ │ ├── hectare.hpp │ │ ├── hour.hpp │ │ ├── knot.hpp │ │ ├── liter.hpp │ │ ├── micron.hpp │ │ ├── minute.hpp │ │ ├── mmHg.hpp │ │ ├── nautical_mile.hpp │ │ ├── ton.hpp │ │ ├── torr.hpp │ │ └── year.hpp │ ├── si │ │ ├── ampere.hpp │ │ ├── candela.hpp │ │ ├── kelvin.hpp │ │ ├── kilogram.hpp │ │ ├── meter.hpp │ │ ├── mole.hpp │ │ └── second.hpp │ ├── temperature │ │ ├── celsius.hpp │ │ ├── conversions.hpp │ │ └── fahrenheit.hpp │ └── us │ │ ├── cup.hpp │ │ ├── dram.hpp │ │ ├── fluid_dram.hpp │ │ ├── fluid_ounce.hpp │ │ ├── foot.hpp │ │ ├── gallon.hpp │ │ ├── gill.hpp │ │ ├── grain.hpp │ │ ├── hundredweight.hpp │ │ ├── inch.hpp │ │ ├── mil.hpp │ │ ├── mile.hpp │ │ ├── minim.hpp │ │ ├── ounce.hpp │ │ ├── pint.hpp │ │ ├── pound.hpp │ │ ├── pound_force.hpp │ │ ├── quart.hpp │ │ ├── tablespoon.hpp │ │ ├── teaspoon.hpp │ │ ├── ton.hpp │ │ └── yard.hpp │ ├── cmath.hpp │ ├── config.hpp │ ├── conversion.hpp │ ├── derived_dimension.hpp │ ├── detail │ ├── absolute_impl.hpp │ ├── cmath_impl.hpp │ ├── conversion_impl.hpp │ ├── dim_impl.hpp │ ├── dimension_impl.hpp │ ├── dimension_list.hpp │ ├── dimensionless_unit.hpp │ ├── heterogeneous_conversion.hpp │ ├── linear_algebra.hpp │ ├── one.hpp │ ├── ordinal.hpp │ ├── prevent_redefinition.hpp │ ├── push_front_if.hpp │ ├── push_front_or_add.hpp │ ├── sort.hpp │ ├── static_rational_power.hpp │ ├── unscale.hpp │ └── utility.hpp │ ├── dim.hpp │ ├── dimension.hpp │ ├── dimensionless_quantity.hpp │ ├── dimensionless_type.hpp │ ├── dimensionless_unit.hpp │ ├── get_dimension.hpp │ ├── get_system.hpp │ ├── heterogeneous_system.hpp │ ├── homogeneous_system.hpp │ ├── io.hpp │ ├── is_dim.hpp │ ├── is_dimension_list.hpp │ ├── is_dimensionless.hpp │ ├── is_dimensionless_quantity.hpp │ ├── is_dimensionless_unit.hpp │ ├── is_quantity.hpp │ ├── is_quantity_of_dimension.hpp │ ├── is_quantity_of_system.hpp │ ├── is_unit.hpp │ ├── is_unit_of_dimension.hpp │ ├── is_unit_of_system.hpp │ ├── lambda.hpp │ ├── limits.hpp │ ├── make_scaled_unit.hpp │ ├── make_system.hpp │ ├── operators.hpp │ ├── physical_dimensions.hpp │ ├── physical_dimensions │ ├── absorbed_dose.hpp │ ├── acceleration.hpp │ ├── action.hpp │ ├── activity.hpp │ ├── amount.hpp │ ├── angular_acceleration.hpp │ ├── angular_momentum.hpp │ ├── angular_velocity.hpp │ ├── area.hpp │ ├── capacitance.hpp │ ├── conductance.hpp │ ├── conductivity.hpp │ ├── current.hpp │ ├── dose_equivalent.hpp │ ├── dynamic_viscosity.hpp │ ├── electric_charge.hpp │ ├── electric_potential.hpp │ ├── energy.hpp │ ├── energy_density.hpp │ ├── force.hpp │ ├── frequency.hpp │ ├── heat_capacity.hpp │ ├── illuminance.hpp │ ├── impedance.hpp │ ├── inductance.hpp │ ├── information.hpp │ ├── kinematic_viscosity.hpp │ ├── length.hpp │ ├── luminance.hpp │ ├── luminous_flux.hpp │ ├── luminous_intensity.hpp │ ├── magnetic_field_intensity.hpp │ ├── magnetic_flux.hpp │ ├── magnetic_flux_density.hpp │ ├── mass.hpp │ ├── mass_density.hpp │ ├── molar_energy.hpp │ ├── molar_heat_capacity.hpp │ ├── moment_of_inertia.hpp │ ├── momentum.hpp │ ├── permeability.hpp │ ├── permittivity.hpp │ ├── plane_angle.hpp │ ├── power.hpp │ ├── pressure.hpp │ ├── reluctance.hpp │ ├── resistance.hpp │ ├── resistivity.hpp │ ├── solid_angle.hpp │ ├── specific_energy.hpp │ ├── specific_heat_capacity.hpp │ ├── specific_volume.hpp │ ├── stress.hpp │ ├── surface_density.hpp │ ├── surface_tension.hpp │ ├── temperature.hpp │ ├── thermal_conductivity.hpp │ ├── time.hpp │ ├── torque.hpp │ ├── velocity.hpp │ ├── volume.hpp │ └── wavenumber.hpp │ ├── pow.hpp │ ├── quantity.hpp │ ├── reduce_unit.hpp │ ├── scale.hpp │ ├── scaled_base_unit.hpp │ ├── static_constant.hpp │ ├── static_rational.hpp │ ├── systems │ ├── abstract.hpp │ ├── angle │ │ ├── degrees.hpp │ │ ├── gradians.hpp │ │ └── revolutions.hpp │ ├── cgs.hpp │ ├── cgs │ │ ├── acceleration.hpp │ │ ├── area.hpp │ │ ├── base.hpp │ │ ├── current.hpp │ │ ├── dimensionless.hpp │ │ ├── dynamic_viscosity.hpp │ │ ├── energy.hpp │ │ ├── force.hpp │ │ ├── frequency.hpp │ │ ├── io.hpp │ │ ├── kinematic_viscosity.hpp │ │ ├── length.hpp │ │ ├── mass.hpp │ │ ├── mass_density.hpp │ │ ├── momentum.hpp │ │ ├── power.hpp │ │ ├── pressure.hpp │ │ ├── time.hpp │ │ ├── velocity.hpp │ │ ├── volume.hpp │ │ └── wavenumber.hpp │ ├── detail │ │ └── constants.hpp │ ├── information.hpp │ ├── information │ │ ├── bit.hpp │ │ ├── byte.hpp │ │ ├── hartley.hpp │ │ ├── nat.hpp │ │ ├── prefixes.hpp │ │ └── shannon.hpp │ ├── si.hpp │ ├── si │ │ ├── absorbed_dose.hpp │ │ ├── acceleration.hpp │ │ ├── action.hpp │ │ ├── activity.hpp │ │ ├── amount.hpp │ │ ├── angular_acceleration.hpp │ │ ├── angular_momentum.hpp │ │ ├── angular_velocity.hpp │ │ ├── area.hpp │ │ ├── base.hpp │ │ ├── capacitance.hpp │ │ ├── catalytic_activity.hpp │ │ ├── codata │ │ │ ├── alpha_constants.hpp │ │ │ ├── atomic-nuclear_constants.hpp │ │ │ ├── deuteron_constants.hpp │ │ │ ├── electromagnetic_constants.hpp │ │ │ ├── electron_constants.hpp │ │ │ ├── helion_constants.hpp │ │ │ ├── muon_constants.hpp │ │ │ ├── neutron_constants.hpp │ │ │ ├── physico-chemical_constants.hpp │ │ │ ├── proton_constants.hpp │ │ │ ├── tau_constants.hpp │ │ │ ├── triton_constants.hpp │ │ │ ├── typedefs.hpp │ │ │ └── universal_constants.hpp │ │ ├── codata_constants.hpp │ │ ├── conductance.hpp │ │ ├── conductivity.hpp │ │ ├── current.hpp │ │ ├── dimensionless.hpp │ │ ├── dose_equivalent.hpp │ │ ├── dynamic_viscosity.hpp │ │ ├── electric_charge.hpp │ │ ├── electric_potential.hpp │ │ ├── energy.hpp │ │ ├── force.hpp │ │ ├── frequency.hpp │ │ ├── illuminance.hpp │ │ ├── impedance.hpp │ │ ├── inductance.hpp │ │ ├── io.hpp │ │ ├── kinematic_viscosity.hpp │ │ ├── length.hpp │ │ ├── luminous_flux.hpp │ │ ├── luminous_intensity.hpp │ │ ├── magnetic_field_intensity.hpp │ │ ├── magnetic_flux.hpp │ │ ├── magnetic_flux_density.hpp │ │ ├── mass.hpp │ │ ├── mass_density.hpp │ │ ├── moment_of_inertia.hpp │ │ ├── momentum.hpp │ │ ├── permeability.hpp │ │ ├── permittivity.hpp │ │ ├── plane_angle.hpp │ │ ├── power.hpp │ │ ├── prefixes.hpp │ │ ├── pressure.hpp │ │ ├── reluctance.hpp │ │ ├── resistance.hpp │ │ ├── resistivity.hpp │ │ ├── solid_angle.hpp │ │ ├── surface_density.hpp │ │ ├── surface_tension.hpp │ │ ├── temperature.hpp │ │ ├── time.hpp │ │ ├── torque.hpp │ │ ├── velocity.hpp │ │ ├── volume.hpp │ │ └── wavenumber.hpp │ └── temperature │ │ ├── celsius.hpp │ │ └── fahrenheit.hpp │ ├── unit.hpp │ └── units_fwd.hpp ├── index.html ├── meta └── libraries.json ├── test ├── Jamfile.v2 ├── check_conversion_defs.cpp ├── fail_add_temperature.cpp ├── fail_adl_detail.cpp ├── fail_base_dimension.cpp ├── fail_heterogeneous_unit.cpp ├── fail_implicit_conversion.cpp ├── fail_quantity_add.cpp ├── fail_quantity_add_assign.cpp ├── fail_quantity_assign.cpp ├── fail_quantity_construct.cpp ├── fail_quantity_non_unit.cpp ├── fail_quantity_scalar_add.cpp ├── fail_quantity_scalar_sub.cpp ├── fail_quantity_sub_assign.cpp ├── fail_quantity_subtract.cpp ├── fail_quantity_unit_add.cpp ├── fail_quantity_unit_subtract.cpp ├── fail_scalar_quantity_add.cpp ├── fail_scalar_quantity_sub.cpp ├── fail_unit_quantity_add.cpp ├── fail_unit_quantity_subtract.cpp ├── test_absolute.cpp ├── test_base_dimension.cpp ├── test_close.hpp ├── test_cmath.cpp ├── test_complicated_system.cpp ├── test_constants.cpp ├── test_conversion.cpp ├── test_custom_unit.cpp ├── test_default_conversion.cpp ├── test_dimensionless_ice1.cpp ├── test_dimensionless_ice2.cpp ├── test_dimensionless_quantity.cpp ├── test_header.hpp ├── test_implicit_conversion.cpp ├── test_information_units.cpp ├── test_lambda.cpp ├── test_limits.cpp ├── test_mixed_value_types.cpp ├── test_negative_denominator.cpp ├── test_output.cpp ├── test_predicates.cpp ├── test_quantity.cpp ├── test_reduce_unit.cpp ├── test_scaled_conversion.cpp ├── test_scaled_unit.cpp ├── test_sqrt_scaled_unit.cpp ├── test_trig.cpp ├── test_unit.cpp └── test_unscale.cpp ├── test_headers ├── Jamfile.v2 ├── main.cpp └── test.cpp └── tutorial └── tutorial_1.cpp /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Generated by `boostdep --cmake units` 2 | # Copyright 2020 Peter Dimov 3 | # Distributed under the Boost Software License, Version 1.0. 4 | # https://www.boost.org/LICENSE_1_0.txt 5 | 6 | cmake_minimum_required(VERSION 3.5...3.16) 7 | 8 | project(boost_units VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX) 9 | 10 | add_library(boost_units INTERFACE) 11 | add_library(Boost::units ALIAS boost_units) 12 | 13 | target_include_directories(boost_units INTERFACE include) 14 | 15 | target_link_libraries(boost_units 16 | INTERFACE 17 | Boost::assert 18 | Boost::config 19 | Boost::core 20 | Boost::integer 21 | Boost::io 22 | Boost::lambda 23 | Boost::math 24 | Boost::mpl 25 | Boost::preprocessor 26 | Boost::static_assert 27 | Boost::type_traits 28 | Boost::typeof 29 | ) 30 | 31 | if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt") 32 | 33 | add_subdirectory(test) 34 | 35 | endif() 36 | 37 | -------------------------------------------------------------------------------- /boost.css: -------------------------------------------------------------------------------- 1 | /*============================================================================= 2 | Copyright 2002 William E. Kempf 3 | Distributed under the Boost Software License, Version 1.0. (See accompany- 4 | ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | =============================================================================*/ 6 | 7 | H1 8 | { 9 | FONT-SIZE: 200%; 10 | COLOR: #00008B; 11 | } 12 | H2 13 | { 14 | FONT-SIZE: 150%; 15 | } 16 | H3 17 | { 18 | FONT-SIZE: 125%; 19 | } 20 | H4 21 | { 22 | FONT-SIZE: 108%; 23 | } 24 | BODY 25 | { 26 | FONT-SIZE: 100%; 27 | BACKGROUND-COLOR: #ffffff; 28 | } 29 | PRE 30 | { 31 | MARGIN-LEFT: 2em; 32 | FONT-FAMILY: Courier, 33 | monospace; 34 | } 35 | CODE 36 | { 37 | FONT-FAMILY: Courier, 38 | monospace; 39 | } 40 | CODE.as_pre 41 | { 42 | white-space: pre; 43 | } 44 | .index 45 | { 46 | TEXT-ALIGN: left; 47 | } 48 | .page-index 49 | { 50 | TEXT-ALIGN: left; 51 | } 52 | .definition 53 | { 54 | TEXT-ALIGN: left; 55 | } 56 | .footnote 57 | { 58 | FONT-SIZE: 66%; 59 | VERTICAL-ALIGN: super; 60 | TEXT-DECORATION: none; 61 | } 62 | .function-semantics 63 | { 64 | CLEAR: left; 65 | } -------------------------------------------------------------------------------- /build.jam: -------------------------------------------------------------------------------- 1 | # Copyright René Ferdinand Rivera Morell 2023-2024 2 | # Distributed under the Boost Software License, Version 1.0. 3 | # (See accompanying file LICENSE_1_0.txt or copy at 4 | # http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | require-b2 5.2 ; 7 | 8 | constant boost_dependencies : 9 | /boost/assert//boost_assert 10 | /boost/config//boost_config 11 | /boost/core//boost_core 12 | /boost/integer//boost_integer 13 | /boost/io//boost_io 14 | /boost/lambda//boost_lambda 15 | /boost/math//boost_math_tr1 16 | /boost/move//boost_move 17 | /boost/mpl//boost_mpl 18 | /boost/preprocessor//boost_preprocessor 19 | /boost/static_assert//boost_static_assert 20 | /boost/type_traits//boost_type_traits 21 | /boost/typeof//boost_typeof ; 22 | 23 | project /boost/units 24 | ; 25 | 26 | explicit 27 | [ alias boost_units : : : 28 | : include $(boost_dependencies) ] 29 | [ alias all : boost_units example test test_headers ] 30 | ; 31 | 32 | call-if : boost-library units 33 | ; 34 | 35 | -------------------------------------------------------------------------------- /example/Jamfile.v2: -------------------------------------------------------------------------------- 1 | # Jamfile.v2 2 | # 3 | # Copyright (c) 2007-2008 4 | # Steven Watanabe 5 | # 6 | # Distributed under the Boost Software License, Version 1.0. (See 7 | # accompanying file LICENSE_1_0.txt or copy at 8 | # http://www.boost.org/LICENSE_1_0.txt 9 | 10 | import testing ; 11 | 12 | project : 13 | : requirements all 14 | /boost/units//boost_units 15 | ; 16 | 17 | files = [ glob *.cpp : performance.* runtime_unit.* ] ; 18 | 19 | for local file in $(files) 20 | { 21 | run $(file) ; 22 | } 23 | 24 | path-constant HERE : . ; 25 | 26 | compile performance.cpp /boost/timer//boost_timer /boost/ublas//boost_ublas : BOOST_TIMER_ENABLE_DEPRECATED ; 27 | run runtime_unit.cpp : <$(HERE)/runtime_unit_input.txt ; 28 | -------------------------------------------------------------------------------- /example/runtime_unit_input.txt: -------------------------------------------------------------------------------- 1 | # runtime_unit_input.txt 2 | # 3 | # Copyright (c) 2007-2008 Steven Watanabe 4 | # 5 | # Distributed under the Boost Software License, Version 1.0. (See 6 | # accompanying file LICENSE_1_0.txt or copy at 7 | # http://www.boost.org/LICENSE_1_0.txt) 8 | 9 | return foot 10 | 2.0 centimeter 11 | return centimeter 12 | 3.0 meter 13 | exit 14 | -------------------------------------------------------------------------------- /images/form_0.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_0.png -------------------------------------------------------------------------------- /images/form_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_1.png -------------------------------------------------------------------------------- /images/form_10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_10.png -------------------------------------------------------------------------------- /images/form_11.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_11.png -------------------------------------------------------------------------------- /images/form_12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_12.png -------------------------------------------------------------------------------- /images/form_13.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_13.png -------------------------------------------------------------------------------- /images/form_14.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_14.png -------------------------------------------------------------------------------- /images/form_15.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_15.png -------------------------------------------------------------------------------- /images/form_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_2.png -------------------------------------------------------------------------------- /images/form_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_3.png -------------------------------------------------------------------------------- /images/form_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_4.png -------------------------------------------------------------------------------- /images/form_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_5.png -------------------------------------------------------------------------------- /images/form_6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_6.png -------------------------------------------------------------------------------- /images/form_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_7.png -------------------------------------------------------------------------------- /images/form_8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_8.png -------------------------------------------------------------------------------- /images/form_9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boostorg/units/605ebf7143be8861f9cf80e54427a8bbffb55212/images/form_9.png -------------------------------------------------------------------------------- /include/boost/units/base_units/angle/arcminute.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_BASE_UNITS_ANGLE_ARCMINUTE_HPP_INCLUDED 12 | #define BOOST_UNIT_BASE_UNITS_ANGLE_ARCMINUTE_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | namespace units { 21 | namespace angle { 22 | 23 | typedef scaled_base_unit > > arcminute_base_unit; 24 | 25 | } 26 | 27 | template<> 28 | struct base_unit_info { 29 | static BOOST_CONSTEXPR const char* name() { return("arcminute"); } 30 | static BOOST_CONSTEXPR const char* symbol() { return("'"); } 31 | }; 32 | 33 | } 34 | } 35 | 36 | #endif // BOOST_UNIT_BASE_UNITS_ANGLE_ARCMINUTE_HPP_INCLUDED 37 | -------------------------------------------------------------------------------- /include/boost/units/base_units/angle/degree.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ANGLE_DEGREE_BASE_UNIT_HPP 12 | #define BOOST_UNITS_ANGLE_DEGREE_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(angle,degree,"degree","deg",6.28318530718/360.,boost::units::angle::radian_base_unit,-101); 18 | 19 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 20 | 21 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 22 | 23 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::angle::degree_base_unit) 24 | 25 | #endif 26 | 27 | #endif // BOOST_UNITS_ANGLE_DEGREE_BASE_UNIT_HPP 28 | -------------------------------------------------------------------------------- /include/boost/units/base_units/angle/gradian.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ANGLE_GRADIAN_BASE_UNIT_HPP 12 | #define BOOST_UNITS_ANGLE_GRADIAN_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(angle,gradian,"gradian","grad",6.28318530718/400.,boost::units::angle::radian_base_unit,-102); 18 | 19 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 20 | 21 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 22 | 23 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::angle::gradian_base_unit) 24 | 25 | #endif 26 | 27 | #endif // BOOST_UNITS_ANGLE_GRADIAN_BASE_UNIT_HPP 28 | -------------------------------------------------------------------------------- /include/boost/units/base_units/angle/revolution.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_BASE_UNITS_REVOLUTION_HPP 12 | #define BOOST_UNITS_BASE_UNITS_REVOLUTION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | namespace units { 21 | namespace angle { 22 | 23 | typedef scaled_base_unit > > revolution_base_unit; 24 | 25 | } 26 | 27 | template<> 28 | struct base_unit_info { 29 | static BOOST_CONSTEXPR const char* name() { return("revolution"); } 30 | static BOOST_CONSTEXPR const char* symbol() { return("rev"); } 31 | }; 32 | 33 | } 34 | } 35 | 36 | #endif // BOOST_UNITS_BASE_UNITS_REVOLUTION_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/base_units/astronomical/astronomical_unit.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_ASTRONOMICAL_ASTRONOMICAL_UNIT_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_ASTRONOMICAL_ASTRONOMICAL_UNIT_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(astronomical, astronomical_unit, "astronomical unit", "a.u.", 149597870691.0, boost::units::si::meter_base_unit, -207); 18 | 19 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 20 | 21 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 22 | 23 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::astronomical::astronomical_unit_base_unit) 24 | 25 | #endif 26 | 27 | #endif // BOOST_UNIT_SYSTEMS_ASTRONOMICAL_ASTRONOMICAL_UNIT_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /include/boost/units/base_units/astronomical/light_second.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_ASTRONOMICAL_LIGHT_SECOND_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_ASTRONOMICAL_LIGHT_SECOND_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(astronomical, light_second, "light second", "lsc", 2.99792458e8, boost::units::si::meter_base_unit, -201); 18 | 19 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 20 | 21 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 22 | 23 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::astronomical::light_second_base_unit) 24 | 25 | #endif 26 | 27 | #endif // BOOST_UNIT_SYSTEMS_ASTRONOMICAL_LIGHT_SECOND_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /include/boost/units/base_units/astronomical/parsec.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_ASTRONOMICAL_PARSEC_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_ASTRONOMICAL_PARSEC_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(astronomical, parsec, "parsec", "psc", 3.0856775813e16, boost::units::si::meter_base_unit, -206); 18 | 19 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 20 | 21 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 22 | 23 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::astronomical::parsec_base_unit) 24 | 25 | #endif 26 | 27 | #endif // BOOST_UNIT_SYSTEMS_ASTRONOMICAL_PARSEC_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /include/boost/units/base_units/cgs/biot.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_BIOT_BASE_UNIT_HPP 12 | #define BOOST_UNITS_CGS_BIOT_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef scaled_base_unit > > biot_base_unit; 24 | 25 | } // namespace cgs 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_CGS_BIOT_BASE_UNIT_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/base_units/cgs/centimeter.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CENTIMETER_BASE_UNIT_HPP 12 | #define BOOST_UNITS_CENTIMETER_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef scaled_base_unit > > centimeter_base_unit; 24 | 25 | } // namespace cgs 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_CENTIMETER_BASE_UNIT_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/base_units/imperial/pint.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_BASE_UNITS_IMPERIAL_PINT_HPP_INCLUDED 12 | #define BOOST_UNITS_BASE_UNITS_IMPERIAL_PINT_HPP_INCLUDED 13 | 14 | #include 15 | 16 | #include 17 | #include 18 | 19 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(imperial, pint, "pint (imp.)", "pt", 4.54609e-3/8., si::volume, -303); // exact conversion 20 | 21 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 22 | 23 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 24 | 25 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::imperial::pint_base_unit) 26 | 27 | #endif 28 | 29 | #endif // BOOST_UNITS_BASE_UNITS_IMPERIAL_PINT_HPP_INCLUDED 30 | -------------------------------------------------------------------------------- /include/boost/units/base_units/imperial/yard.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SYSTEMS_IMPERIAL_YARD_BASE_UNIT_HPP 12 | #define BOOST_UNITS_SYSTEMS_IMPERIAL_YARD_BASE_UNIT_HPP 13 | 14 | #include 15 | 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(imperial, yard, "yard", "yd", 0.9144, si::meter_base_unit, -301); // exact conversion 23 | 24 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 25 | 26 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 27 | 28 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::imperial::yard_base_unit) 29 | 30 | #endif 31 | 32 | #endif // BOOST_UNITS_SYSTEMS_IMPERIAL_YARD_BASE_UNIT_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/base_units/information/hartley.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2014 Erik Erlandson 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. (See 7 | // accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | 10 | #ifndef BOOST_UNITS_BASE_UNITS_INFORMATION_HARTLEY_HPP_INCLUDED 11 | #define BOOST_UNITS_BASE_UNITS_INFORMATION_HARTLEY_HPP_INCLUDED 12 | 13 | #include 14 | #include 15 | 16 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(information, hartley, 17 | "hartley", "Hart", 18 | 3.321928094887363, 19 | boost::units::information::bit_base_unit, 20 | -703); 21 | 22 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 23 | 24 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 25 | 26 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::information::hartley_base_unit) 27 | 28 | #endif 29 | 30 | #endif // BOOST_UNITS_BASE_UNITS_INFORMATION_HARTLEY_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /include/boost/units/base_units/information/nat.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2014 Erik Erlandson 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. (See 7 | // accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | 10 | #ifndef BOOST_UNITS_BASE_UNITS_INFORMATION_NAT_HPP_INCLUDED 11 | #define BOOST_UNITS_BASE_UNITS_INFORMATION_NAT_HPP_INCLUDED 12 | 13 | #include 14 | #include 15 | 16 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(information, nat, 17 | "nat", "nat", 18 | 1.442695040888964, 19 | boost::units::information::bit_base_unit, 20 | -702); 21 | 22 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 23 | 24 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 25 | 26 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::information::nat_base_unit) 27 | 28 | #endif 29 | 30 | #endif // BOOST_UNITS_BASE_UNITS_INFORMATION_NAT_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/are.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_ARE_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_ARE_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, are, "are", "a", 1.0e2, si::area, 10); 18 | 19 | #endif // BOOST_UNIT_SYSTEMS_METRIC_ARE_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/atmosphere.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_ATMOSPHERE_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_ATMOSPHERE_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, atmosphere, "atmosphere", "atm", 1.01325e5, si::pressure, 33); 18 | 19 | #endif // BOOST_UNIT_SYSTEMS_METRIC_ATMOSPHERE_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/bar.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_BAR_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_BAR_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, bar, "bar", "bar", 1.0e5, si::pressure, 14); 18 | 19 | #endif // BOOST_UNIT_SYSTEMS_METRIC_BAR_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/barn.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_BARN_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_BARN_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, barn, "barn", "b", 1.0e-28, si::area, 11); 18 | 19 | #endif // BOOST_UNIT_SYSTEMS_METRIC_BARN_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/day.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_OTHER_DAY_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_OTHER_DAY_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | namespace metric { 24 | 25 | typedef scaled_base_unit > > day_base_unit; 26 | 27 | } // namespace metric 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("day"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("d"); } 33 | }; 34 | 35 | } // namespace units 36 | 37 | } // namespace boost 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/fermi.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_FERMI_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_FERMI_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | namespace units { 21 | namespace metric { 22 | 23 | typedef scaled_base_unit > > fermi_base_unit; 24 | 25 | } 26 | 27 | template<> 28 | struct base_unit_info { 29 | static BOOST_CONSTEXPR const char* name() { return("fermi"); } 30 | static BOOST_CONSTEXPR const char* symbol() { return("fm"); } 31 | }; 32 | 33 | } 34 | } 35 | 36 | #endif // BOOST_UNIT_SYSTEMS_METRIC_FERMI_HPP_INCLUDED 37 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/hectare.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_HECTARE_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_HECTARE_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, hectare, "hectare", "ha", 1.0e4, si::area, 12); 18 | 19 | #endif // BOOST_UNIT_SYSTEMS_METRIC_HECTARE_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/knot.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_KNOT_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_KNOT_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, knot, "knot", "kt", 1852./3600., boost::units::si::velocity, -403); 18 | 19 | #endif // BOOST_UNIT_SYSTEMS_METRIC_KNOT_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/liter.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_LITER_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_LITER_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, liter, "liter", "L", 1.0e-3, si::volume, 13); 18 | 19 | #endif // BOOST_UNIT_SYSTEMS_METRIC_LITER_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/micron.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_MICRON_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_MICRON_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | namespace units { 21 | namespace metric { 22 | 23 | typedef scaled_base_unit > > micron_base_unit; 24 | 25 | } 26 | 27 | template<> 28 | struct base_unit_info { 29 | static BOOST_CONSTEXPR const char* name() { return("micron"); } 30 | static BOOST_CONSTEXPR const char* symbol() { return("u"); } 31 | }; 32 | 33 | } 34 | } 35 | 36 | #endif // BOOST_UNIT_SYSTEMS_METRIC_MICRON_HPP_INCLUDED 37 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/mmHg.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_MMHG_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_MMHG_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, mmHg, "millimeters mercury", "mmHg", 133.322, si::pressure, -404); 18 | 19 | #endif // BOOST_UNIT_SYSTEMS_METRIC_MMHG_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/torr.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_METRIC_TORR_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_METRIC_TORR_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(metric, torr, "torr", "Torr", 1.01325e5/760.0, si::pressure, -401); 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /include/boost/units/base_units/metric/year.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_OTHER_YEAR_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_OTHER_YEAR_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | // Julian year = 365.25 days exactly = 8766 hours exactly 20 | 21 | namespace boost { 22 | namespace units { 23 | namespace metric { 24 | 25 | typedef scaled_base_unit > > year_base_unit; 26 | 27 | } 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("Julian year"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("yr"); } 33 | }; 34 | 35 | } 36 | } 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /include/boost/units/base_units/si/kilogram.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_KILOGRAM_BASE_UNIT_HPP 12 | #define BOOST_UNITS_SI_KILOGRAM_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef scaled_base_unit > > kilogram_base_unit; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_KILOGRAM_BASE_UNIT_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/cup.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_BASE_UNITS_US_CUP_HPP_INCLUDED 12 | #define BOOST_UNITS_BASE_UNITS_US_CUP_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | namespace us { 24 | 25 | typedef scaled_base_unit > > cup_base_unit; 26 | 27 | } // namespace us 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("cup"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("c"); } 33 | }; 34 | 35 | } // namespace units 36 | 37 | } // namespace boost 38 | 39 | #endif // BOOST_UNITS_BASE_UNITS_US_CUP_HPP_INCLUDED 40 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/foot.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_US_FOOT_BASE_UNIT_HPP 12 | #define BOOST_UNITS_US_FOOT_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | namespace us { 24 | 25 | typedef scaled_base_unit > > foot_base_unit; 26 | 27 | } // namespace us 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("foot"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("ft"); } 33 | }; 34 | 35 | } // namespace units 36 | 37 | } // namespace boost 38 | 39 | #endif // BOOST_UNITS_US_FOOT_BASE_UNIT_HPP 40 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/inch.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_US_INCH_BASE_UNIT_HPP 12 | #define BOOST_UNITS_US_INCH_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | namespace us { 24 | 25 | typedef scaled_base_unit > > inch_base_unit; 26 | 27 | } // namespace us 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("inch"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("in"); } 33 | }; 34 | 35 | } // namespace units 36 | 37 | } // namespace boost 38 | 39 | #endif // BOOST_UNITS_US_INCH_BASE_UNIT_HPP 40 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/mil.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_US_MIL_BASE_UNIT_HPP 12 | #define BOOST_UNITS_US_MIL_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | namespace us { 24 | 25 | typedef scaled_base_unit > > mil_base_unit; 26 | 27 | } // namespace us 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("mil"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("mil"); } 33 | }; 34 | 35 | } // namespace units 36 | 37 | } // namespace boost 38 | 39 | #endif // BOOST_UNITS_US_MIL_BASE_UNIT_HPP 40 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/mile.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_US_MILE_BASE_UNIT_HPP 12 | #define BOOST_UNITS_US_MILE_BASE_UNIT_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | namespace us { 24 | 25 | typedef scaled_base_unit > > mile_base_unit; 26 | 27 | } // namespace us 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("mile"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("mi"); } 33 | }; 34 | 35 | } // namespace units 36 | 37 | } // namespace boost 38 | 39 | #endif // BOOST_UNITS_US_MILE_BASE_UNIT_HPP 40 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/ounce.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_US_OUNCE_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_US_OUNCE_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | namespace us { 24 | 25 | typedef scaled_base_unit > > ounce_base_unit; 26 | 27 | } // namespace us 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("ounce"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("oz"); } 33 | }; 34 | 35 | } // namespace units 36 | 37 | } // namespace boost 38 | 39 | #endif // BOOST_UNIT_SYSTEMS_US_OUNCE_HPP_INCLUDED 40 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/pint.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_BASE_UNITS_US_PINT_HPP_INCLUDED 12 | #define BOOST_UNITS_BASE_UNITS_US_PINT_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(us, pint, "pint (U.S.)", "pt", 0.4731765e-3, si::volume, -503); 19 | 20 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 21 | 22 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 23 | 24 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::us::pint_base_unit) 25 | 26 | #endif 27 | 28 | #endif // BOOST_UNITS_BASE_UNITS_US_PINT_HPP_INCLUDED 29 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/pound.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_US_POUND_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_US_POUND_HPP_INCLUDED 13 | 14 | #include 15 | 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(us, pound, "pound", "lb", 453.59237, cgs::gram_base_unit, -502); // exact conversion 23 | 24 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 25 | 26 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 27 | 28 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::us::pound_base_unit) 29 | 30 | #endif 31 | 32 | #endif // BOOST_UNIT_SYSTEMS_US_POUND_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/pound_force.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2009 Matthias Christian Schabel 5 | // Copyright (C) 2007-2009 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_SYSTEMS_US_POUND_FORCE_HPP_INCLUDED 12 | #define BOOST_UNIT_SYSTEMS_US_POUND_FORCE_HPP_INCLUDED 13 | 14 | #include 15 | 16 | #include 17 | #include 18 | //#include 19 | #include 20 | #include 21 | 22 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(us, pound_force, "pound-force", "lbf", 4.4482216152605, si::force, -600); // exact conversion 23 | 24 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 25 | 26 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 27 | 28 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::us::pound_force_base_unit) 29 | 30 | #endif 31 | 32 | #endif // BOOST_UNIT_SYSTEMS_US_POUND_FORCE_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/ton.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNIT_BASE_UNITS_US_TON_HPP_INCLUDED 12 | #define BOOST_UNIT_BASE_UNITS_US_TON_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | namespace us { 24 | 25 | typedef scaled_base_unit > > ton_base_unit; 26 | 27 | } // namespace us 28 | 29 | template<> 30 | struct base_unit_info { 31 | static BOOST_CONSTEXPR const char* name() { return("short ton"); } 32 | static BOOST_CONSTEXPR const char* symbol() { return("t"); } 33 | }; 34 | 35 | } // namespace units 36 | 37 | } // namespace boost 38 | 39 | #endif // BOOST_UNIT_BASE_UNITS_US_TON_HPP_INCLUDED 40 | -------------------------------------------------------------------------------- /include/boost/units/base_units/us/yard.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SYSTEMS_US_YARD_BASE_UNIT_HPP 12 | #define BOOST_UNITS_SYSTEMS_US_YARD_BASE_UNIT_HPP 13 | 14 | #include 15 | 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | BOOST_UNITS_DEFINE_BASE_UNIT_WITH_CONVERSIONS(us, yard, "yard", "yd", 0.9144, si::meter_base_unit, -501); // exact conversion 23 | 24 | #if BOOST_UNITS_HAS_BOOST_TYPEOF 25 | 26 | #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() 27 | 28 | BOOST_TYPEOF_REGISTER_TYPE(boost::units::us::yard_base_unit) 29 | 30 | #endif 31 | 32 | #endif // BOOST_UNITS_SYSTEMS_US_YARD_BASE_UNIT_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/detail/ordinal.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_DETAIL_ORDINAL_HPP_INCLUDED 12 | #define BOOST_UNITS_DETAIL_ORDINAL_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | namespace units { 19 | 20 | namespace detail { 21 | 22 | struct ordinal_tag {}; 23 | 24 | } 25 | 26 | template 27 | struct ordinal { 28 | typedef detail::ordinal_tag tag; 29 | BOOST_STATIC_CONSTEXPR long value = N; 30 | }; 31 | 32 | template 33 | BOOST_CONSTEXPR_OR_CONST long ordinal::value; 34 | 35 | } 36 | 37 | namespace mpl { 38 | 39 | template<> 40 | struct less_impl { 41 | template 42 | struct apply : bool_<(T1::value) < (T2::value)> {}; 43 | }; 44 | 45 | } 46 | 47 | } 48 | 49 | #endif 50 | -------------------------------------------------------------------------------- /include/boost/units/detail/push_front_if.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_DETAIL_PUSH_FRONT_IF_HPP 12 | #define BOOST_UNITS_DETAIL_PUSH_FRONT_IF_HPP 13 | 14 | namespace boost { 15 | 16 | namespace units { 17 | 18 | template 19 | struct list; 20 | 21 | namespace detail { 22 | 23 | template 24 | struct push_front_if; 25 | 26 | template<> 27 | struct push_front_if { 28 | template 29 | struct apply { 30 | typedef list type; 31 | }; 32 | }; 33 | 34 | template<> 35 | struct push_front_if { 36 | template 37 | struct apply { 38 | typedef L type; 39 | }; 40 | }; 41 | 42 | } 43 | 44 | } 45 | 46 | } 47 | 48 | #endif 49 | -------------------------------------------------------------------------------- /include/boost/units/dimensionless_quantity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_DIMENSIONLESS_QUANTITY_HPP 12 | #define BOOST_UNITS_DIMENSIONLESS_QUANTITY_HPP 13 | 14 | /// 15 | /// \file 16 | /// \brief Utility class to simplify construction of dimensionless quantities. 17 | /// 18 | 19 | #include 20 | #include 21 | 22 | namespace boost { 23 | 24 | namespace units { 25 | 26 | /// Utility class to simplify construction of dimensionless quantities. 27 | template 28 | struct dimensionless_quantity 29 | { 30 | typedef quantity::type,Y> type; 31 | }; 32 | 33 | } // namespace units 34 | 35 | } // namespace boost 36 | 37 | #endif // BOOST_UNITS_DIMENSIONLESS_QUANTITY_HPP 38 | -------------------------------------------------------------------------------- /include/boost/units/dimensionless_unit.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_DIMENSIONLESS_UNIT_HPP 12 | #define BOOST_UNITS_DIMENSIONLESS_UNIT_HPP 13 | 14 | /// 15 | /// \file 16 | /// \brief Utility class to simplify construction of dimensionless units in a system. 17 | /// 18 | 19 | #include 20 | #include 21 | 22 | namespace boost { 23 | 24 | namespace units { 25 | 26 | /// Utility class to simplify construction of dimensionless units in a system. 27 | template 28 | struct dimensionless_unit 29 | { 30 | typedef unit type; 31 | }; 32 | 33 | } // namespace units 34 | 35 | } // namespace boost 36 | 37 | #endif // BOOST_UNITS_DIMENSIONLESS_UNIT_HPP 38 | -------------------------------------------------------------------------------- /include/boost/units/is_dim.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_IS_DIM_HPP 12 | #define BOOST_UNITS_IS_DIM_HPP 13 | 14 | /// 15 | /// \file 16 | /// \brief Check that a type is a valid @c dim. 17 | /// 18 | 19 | #include 20 | 21 | #include 22 | 23 | namespace boost { 24 | 25 | namespace units { 26 | 27 | /// Check that a type is a valid @c dim. 28 | template 29 | struct is_dim : 30 | public mpl::false_ 31 | { }; 32 | 33 | template 34 | struct is_dim< dim > : 35 | public mpl::true_ 36 | { }; 37 | 38 | } // namespace units 39 | 40 | } // namespace boost 41 | 42 | #endif // BOOST_UNITS_IS_DIM_HPP 43 | -------------------------------------------------------------------------------- /include/boost/units/is_dimension_list.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_IS_DIMENSION_LIST_HPP 12 | #define BOOST_UNITS_IS_DIMENSION_LIST_HPP 13 | 14 | /// 15 | /// \file 16 | /// \brief Check that a type is a valid dimension list. 17 | /// 18 | 19 | #include 20 | 21 | #include 22 | 23 | namespace boost { 24 | 25 | namespace units { 26 | 27 | /// Check that a type is a valid dimension list. 28 | template 29 | struct is_dimension_list : 30 | public mpl::false_ 31 | { }; 32 | 33 | template 34 | struct is_dimension_list > : 35 | public mpl::true_ 36 | { }; 37 | 38 | template<> 39 | struct is_dimension_list : 40 | public mpl::true_ 41 | { }; 42 | 43 | } // namespace units 44 | 45 | } // namespace boost 46 | 47 | #endif // BOOST_UNITS_IS_DIMENSION_LIST_HPP 48 | -------------------------------------------------------------------------------- /include/boost/units/is_dimensionless_quantity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_IS_DIMENSIONLESS_QUANTITY_HPP 12 | #define BOOST_UNITS_IS_DIMENSIONLESS_QUANTITY_HPP 13 | 14 | /// \file 15 | /// \brief check that a type is a dimensionless quantity 16 | 17 | #include 18 | #include 19 | 20 | namespace boost { 21 | 22 | namespace units { 23 | 24 | /// Check that a type is a dimensionless quantity. 25 | template 26 | struct is_dimensionless_quantity : 27 | public is_quantity_of_dimension 28 | { }; 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_IS_DIMENSIONLESS_QUANTITY_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/is_dimensionless_unit.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_IS_DIMENSIONLESS_UNIT_HPP 12 | #define BOOST_UNITS_IS_DIMENSIONLESS_UNIT_HPP 13 | 14 | /// \file 15 | /// \brief Check that a type is a dimensionless unit. 16 | 17 | #include 18 | #include 19 | 20 | namespace boost { 21 | 22 | namespace units { 23 | 24 | /// Check that a type is a dimensionless unit. 25 | template 26 | struct is_dimensionless_unit : 27 | public is_unit_of_dimension 28 | { }; 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_IS_DIMENSIONLESS_UNIT_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/is_quantity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_IS_QUANTITY_HPP 12 | #define BOOST_UNITS_IS_QUANTITY_HPP 13 | 14 | /// 15 | /// \file 16 | /// \brief Check that a type is a quantity. 17 | /// 18 | 19 | #include 20 | #include 21 | 22 | namespace boost { 23 | 24 | namespace units { 25 | 26 | /// Check that a type is a quantity. 27 | template 28 | struct is_quantity : 29 | public mpl::false_ 30 | { }; 31 | 32 | template 34 | struct is_quantity< quantity > : 35 | public mpl::true_ 36 | { }; 37 | 38 | } // namespace units 39 | 40 | } // namespace boost 41 | 42 | #endif // BOOST_UNITS_IS_QUANTITY_HPP 43 | -------------------------------------------------------------------------------- /include/boost/units/is_unit.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_IS_UNIT_HPP 12 | #define BOOST_UNITS_IS_UNIT_HPP 13 | 14 | /// 15 | /// \file 16 | /// \brief Check that a type is a unit. 17 | /// 18 | 19 | #include 20 | #include 21 | 22 | namespace boost { 23 | 24 | namespace units { 25 | 26 | /// Check that a type is a unit. 27 | template 28 | struct is_unit : 29 | public mpl::false_ 30 | { }; 31 | 32 | template 33 | struct is_unit< unit > : 34 | public mpl::true_ 35 | { }; 36 | 37 | } // namespace units 38 | 39 | } // namespace boost 40 | 41 | #endif // BOOST_UNITS_IS_UNIT_HPP 42 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/absorbed_dose.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ABSORBED_DOSE_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ABSORBED_DOSE_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for absorbed dose : L^2 T^-2 23 | typedef derived_dimension::type absorbed_dose_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_ABSORBED_DOSE_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/acceleration.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ACCELERATION_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ACCELERATION_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for acceleration : L T^-2 23 | typedef derived_dimension::type acceleration_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_ACCELERATION_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/action.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ACTION_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ACTION_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for action : L^2 M T^-1 24 | typedef derived_dimension::type action_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_ACTION_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/activity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ACTIVITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ACTIVITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | /// derived dimension for activity : T^-1 22 | typedef derived_dimension::type activity_dimension; 23 | 24 | } // namespace units 25 | 26 | } // namespace boost 27 | 28 | #endif // BOOST_UNITS_ACTIVITY_DERIVED_DIMENSION_HPP 29 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/angular_acceleration.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ANGULAR_ACCELERATION_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ANGULAR_ACCELERATION_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for angular acceleration : T^-2 QP 23 | typedef derived_dimension::type angular_acceleration_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_ANGULAR_ACCELERATION_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/angular_velocity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ANGULAR_VELOCITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ANGULAR_VELOCITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for angular velocity : T^-1 QP 23 | typedef derived_dimension::type angular_velocity_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_ANGULAR_VELOCITY_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/area.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_AREA_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_AREA_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | /// derived dimension for area : L^2 22 | typedef derived_dimension::type area_dimension; 23 | 24 | } // namespace units 25 | 26 | } // namespace boost 27 | 28 | #endif // BOOST_UNITS_AREA_DERIVED_DIMENSION_HPP 29 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/dose_equivalent.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_DOSE_EQUIVALENT_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_DOSE_EQUIVALENT_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for dose equivalent : L^2 T^-2 23 | typedef derived_dimension::type dose_equivalent_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_DOSE_EQUIVALENT_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/dynamic_viscosity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_DYNAMIC_VISCOSITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_DYNAMIC_VISCOSITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for dynamic viscosity : M L^-1 T^-1 24 | typedef derived_dimension::type dynamic_viscosity_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_DYNAMIC_VISCOSITY_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/electric_charge.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ELECTRIC_CHARGE_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ELECTRIC_CHARGE_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for electric charge : T^1 I^1 23 | typedef derived_dimension::type electric_charge_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_ELECTRIC_CHARGE_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/energy.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ENERGY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ENERGY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for energy : L^2 M T^-2 24 | typedef derived_dimension::type energy_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_ENERGY_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/energy_density.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ENERGY_DENSITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ENERGY_DENSITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for energy density : L^-1 M^1 T^-2 24 | typedef derived_dimension::type energy_density_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_ENERGY_DENSITY_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/force.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_FORCE_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_FORCE_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for force : L M T^-2 24 | typedef derived_dimension::type force_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_FORCE_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/frequency.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_FREQUENCY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_FREQUENCY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | /// derived dimension for frequency : T^-1 22 | typedef derived_dimension::type frequency_dimension; 23 | 24 | } // namespace units 25 | 26 | } // namespace boost 27 | 28 | #endif // BOOST_UNITS_FREQUENCY_DERIVED_DIMENSION_HPP 29 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/illuminance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_ILLUMINANCE_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_ILLUMINANCE_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for illuminance : L^-2 I QS 24 | typedef derived_dimension::type illuminance_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_ILLUMINANCE_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/kinematic_viscosity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_KINEMATIC_VISCOSITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_KINEMATIC_VISCOSITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for kinematic viscosity : L^2 T^-1 23 | typedef derived_dimension::type kinematic_viscosity_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_KINEMATIC_VISCOSITY_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/luminance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_LUMINANCE_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_LUMINANCE_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for luminance : L^-2 I 23 | typedef derived_dimension::type luminance_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_LUMINANCE_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/luminous_flux.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_LUMINOUS_FLUX_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_LUMINOUS_FLUX_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for luminous flux : I QS 23 | typedef derived_dimension::type luminous_flux_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_LUMINOUS_FLUX_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/magnetic_field_intensity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_MAGNETIC_FIELD_INTENSITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_MAGNETIC_FIELD_INTENSITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for magnetic field intensity : L^-1 I 23 | typedef derived_dimension::type magnetic_field_intensity_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_MAGNETIC_FIELD_INTENSITY_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/magnetic_flux_density.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_MAGNETIC_FLUX_DENSITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_MAGNETIC_FLUX_DENSITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for magnetic flux density : M T^-2 I^-1 24 | typedef derived_dimension::type magnetic_flux_density_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_MAGNETIC_FLUX_DENSITY_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/mass_density.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_MASS_DENSITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_MASS_DENSITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for mass density : L^-3 M 23 | typedef derived_dimension::type mass_density_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_MASS_DENSITY_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/moment_of_inertia.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_MOMENT_OF_INERTIA_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_MOMENT_OF_INERTIA_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for moment of inertia : L^2 M QP^-2 24 | typedef derived_dimension::type moment_of_inertia_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_MOMENT_OF_INERTIA_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/momentum.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_MOMENTUM_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_MOMENTUM_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for linear momentum : L M T^-1 24 | typedef derived_dimension::type momentum_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_MOMENTUM_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/power.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_POWER_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_POWER_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for power : L^2 M T^-3 24 | typedef derived_dimension::type power_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_POWER_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/pressure.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_PRESSURE_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_PRESSURE_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for pressure : L^-1 M T^-2 24 | typedef derived_dimension::type pressure_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_PRESSURE_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/specific_energy.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SPECIFIC_ENERGY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_SPECIFIC_ENERGY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for specific energy : L^2 T^-2 23 | typedef derived_dimension::type specific_energy_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_SPECIFIC_ENERGY_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/specific_volume.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SPECIFIC_VOLUME_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_SPECIFIC_VOLUME_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for specific volume : L^3 M^-1 23 | typedef derived_dimension::type specific_volume_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_SPECIFIC_VOLUME_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/stress.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_STRESS_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_STRESS_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for stress : L^-1 M T^-2 24 | typedef derived_dimension::type stress_dimension; 27 | 28 | } // namespace units 29 | 30 | } // namespace boost 31 | 32 | #endif // BOOST_UNITS_STRESS_DERIVED_DIMENSION_HPP 33 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/surface_density.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SURFACE_DENSITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_SURFACE_DENSITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for surface density : L^-2 M 23 | typedef derived_dimension::type surface_density_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_SURFACE_DENSITY_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/surface_tension.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SURFACE_TENSION_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_SURFACE_TENSION_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | namespace boost { 20 | 21 | namespace units { 22 | 23 | /// derived dimension for surface tension : M T^-2 24 | typedef derived_dimension::type surface_tension_dimension; 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SURFACE_TENSION_DERIVED_DIMENSION_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/velocity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_VELOCITY_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_VELOCITY_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | namespace units { 21 | 22 | /// derived dimension for velocity : L T^-1 23 | typedef derived_dimension::type velocity_dimension; 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_VELOCITY_DERIVED_DIMENSION_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/volume.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_VOLUME_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_VOLUME_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | /// derived dimension for volume : l^3 22 | typedef derived_dimension::type volume_dimension; 23 | 24 | } // namespace units 25 | 26 | } // namespace boost 27 | 28 | #endif // BOOST_UNITS_VOLUME_DERIVED_DIMENSION_HPP 29 | -------------------------------------------------------------------------------- /include/boost/units/physical_dimensions/wavenumber.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_WAVENUMBER_DERIVED_DIMENSION_HPP 12 | #define BOOST_UNITS_WAVENUMBER_DERIVED_DIMENSION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | /// derived dimension for wavenumber : L^-1 22 | typedef derived_dimension::type wavenumber_dimension; 23 | 24 | } // namespace units 25 | 26 | } // namespace boost 27 | 28 | #endif // BOOST_UNITS_WAVENUMBER_DERIVED_DIMENSION_HPP 29 | -------------------------------------------------------------------------------- /include/boost/units/reduce_unit.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_REDUCE_UNIT_HPP_INCLUDED 12 | #define BOOST_UNITS_REDUCE_UNIT_HPP_INCLUDED 13 | 14 | /// \file 15 | /// \brief Returns a unique type for every unit. 16 | 17 | namespace boost { 18 | namespace units { 19 | 20 | #ifdef BOOST_UNITS_DOXYGEN 21 | 22 | /// Returns a unique type for every unit. 23 | template 24 | struct reduce_unit { 25 | typedef detail::unspecified type; 26 | }; 27 | 28 | #else 29 | 30 | // default implementation: return Unit unchanged. 31 | template 32 | struct reduce_unit { 33 | typedef Unit type; 34 | }; 35 | 36 | #endif 37 | 38 | } 39 | } 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/acceleration.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_ACCELERATION_HPP 12 | #define BOOST_UNITS_CGS_ACCELERATION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit acceleration; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(gal,acceleration); 26 | BOOST_UNITS_STATIC_CONSTANT(gals,acceleration); 27 | 28 | } // namespace cgs 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_CGS_ACCELERATION_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/area.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_AREA_HPP 12 | #define BOOST_UNITS_CGS_AREA_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit area; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(square_centimeter,area); 26 | BOOST_UNITS_STATIC_CONSTANT(square_centimeters,area); 27 | BOOST_UNITS_STATIC_CONSTANT(square_centimetre,area); 28 | BOOST_UNITS_STATIC_CONSTANT(square_centimetres,area); 29 | 30 | } // namespace cgs 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_CGS_AREA_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/current.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_CURRENT_HPP 12 | #define BOOST_UNITS_CGS_CURRENT_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace cgs { 21 | 22 | typedef unit current; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(biot,current); 25 | BOOST_UNITS_STATIC_CONSTANT(biots,current); 26 | 27 | } // namespace cgs 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_CGS_CURRENT_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/dimensionless.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_DIMENSIONLESS_HPP 12 | #define BOOST_UNITS_CGS_DIMENSIONLESS_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace cgs { 21 | 22 | BOOST_UNITS_STATIC_CONSTANT(cgs_dimensionless,dimensionless); 23 | 24 | } // namespace cgs 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_CGS_DIMENSIONLESS_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/dynamic_viscosity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_DYNAMIC_VISCOSITY_HPP 12 | #define BOOST_UNITS_CGS_DYNAMIC_VISCOSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit dynamic_viscosity; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(poise,dynamic_viscosity); 26 | 27 | } // namespace cgs 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_CGS_DYNAMIC_VISCOSITY_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/energy.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_ENERGY_HPP 12 | #define BOOST_UNITS_CGS_ENERGY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit energy; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(erg,energy); 26 | BOOST_UNITS_STATIC_CONSTANT(ergs,energy); 27 | 28 | } // namespace cgs 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_CGS_ENERGY_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/force.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_FORCE_HPP 12 | #define BOOST_UNITS_CGS_FORCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit force; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(dyne,force); 26 | BOOST_UNITS_STATIC_CONSTANT(dynes,force); 27 | 28 | } // namespace cgs 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_CGS_FORCE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/frequency.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_FREQUENCY_HPP 12 | #define BOOST_UNITS_CGS_FREQUENCY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit frequency; 24 | 25 | } // namespace cgs 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_CGS_FREQUENCY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/kinematic_viscosity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_KINEMATIC_VISCOSITY_HPP 12 | #define BOOST_UNITS_CGS_KINEMATIC_VISCOSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit kinematic_viscosity; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(stoke,kinematic_viscosity); 26 | BOOST_UNITS_STATIC_CONSTANT(stokes,kinematic_viscosity); 27 | 28 | } // namespace cgs 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_CGS_KINEMATIC_VISCOSITY_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/length.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_LENGTH_HPP 12 | #define BOOST_UNITS_CGS_LENGTH_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace cgs { 21 | 22 | typedef unit length; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(centimeter,length); 25 | BOOST_UNITS_STATIC_CONSTANT(centimeters,length); 26 | BOOST_UNITS_STATIC_CONSTANT(centimetre,length); 27 | BOOST_UNITS_STATIC_CONSTANT(centimetres,length); 28 | 29 | } // namespace cgs 30 | 31 | } // namespace units 32 | 33 | } // namespace boost 34 | 35 | #endif // BOOST_UNITS_CGS_LENGTH_HPP 36 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/mass.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_MASS_HPP 12 | #define BOOST_UNITS_CGS_MASS_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace cgs { 21 | 22 | typedef unit mass; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(gram,mass); 25 | BOOST_UNITS_STATIC_CONSTANT(grams,mass); 26 | BOOST_UNITS_STATIC_CONSTANT(gramme,mass); 27 | BOOST_UNITS_STATIC_CONSTANT(grammes,mass); 28 | 29 | 30 | } // namespace cgs 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_CGS_MASS_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/mass_density.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_MASS_DENSITY_HPP 12 | #define BOOST_UNITS_CGS_MASS_DENSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit mass_density; 24 | 25 | } // namespace cgs 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_CGS_MASS_DENSITY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/momentum.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_MOMENTUM_HPP 12 | #define BOOST_UNITS_CGS_MOMENTUM_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit momentum; 24 | 25 | } // namespace cgs 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_CGS_MOMENTUM_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/power.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_POWER_HPP 12 | #define BOOST_UNITS_CGS_POWER_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit power; 24 | 25 | } // namespace cgs 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_CGS_POWER_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/pressure.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_PRESSURE_HPP 12 | #define BOOST_UNITS_CGS_PRESSURE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit pressure; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(barye,pressure); 26 | BOOST_UNITS_STATIC_CONSTANT(baryes,pressure); 27 | 28 | } // namespace cgs 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_CGS_PRESSURE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/time.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_TIME_HPP 12 | #define BOOST_UNITS_CGS_TIME_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace cgs { 21 | 22 | typedef unit time; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(second,time); 25 | BOOST_UNITS_STATIC_CONSTANT(seconds,time); 26 | 27 | } // namespace cgs 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_CGS_TIME_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/velocity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_VELOCITY_HPP 12 | #define BOOST_UNITS_CGS_VELOCITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit velocity; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(centimeter_per_second,velocity); 26 | BOOST_UNITS_STATIC_CONSTANT(centimeters_per_second,velocity); 27 | BOOST_UNITS_STATIC_CONSTANT(centimetre_per_second,velocity); 28 | BOOST_UNITS_STATIC_CONSTANT(centimetres_per_second,velocity); 29 | 30 | } // namespace cgs 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_CGS_VELOCITY_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/cgs/volume.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CGS_VOLUME_HPP 12 | #define BOOST_UNITS_CGS_VOLUME_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace cgs { 22 | 23 | typedef unit volume; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(cubic_centimeter,volume); 26 | BOOST_UNITS_STATIC_CONSTANT(cubic_centimeters,volume); 27 | BOOST_UNITS_STATIC_CONSTANT(cubic_centimetre,volume); 28 | BOOST_UNITS_STATIC_CONSTANT(cubic_centimetres,volume); 29 | 30 | } // namespace cgs 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_CGS_VOLUME_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/information.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2014 Erik Erlandson 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. (See 7 | // accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | 10 | #ifndef BOOST_UNITS_INFORMATION_HPP 11 | #define BOOST_UNITS_INFORMATION_HPP 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /include/boost/units/systems/information/bit.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2014 Erik Erlandson 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. (See 7 | // accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | 10 | #ifndef BOOST_UNITS_SYSTEMS_INFORMATION_BIT_HPP_INCLUDED 11 | #define BOOST_UNITS_SYSTEMS_INFORMATION_BIT_HPP_INCLUDED 12 | 13 | #include 14 | #include 15 | 16 | namespace boost { 17 | namespace units { 18 | namespace information { 19 | 20 | namespace hu { 21 | namespace bit { 22 | typedef unit::type> info; 23 | } // namespace bit 24 | } // namespace hu 25 | 26 | BOOST_UNITS_STATIC_CONSTANT(bit, hu::bit::info); 27 | BOOST_UNITS_STATIC_CONSTANT(bits, hu::bit::info); 28 | 29 | } // namespace information 30 | } // namespace units 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SYSTEMS_INFORMATION_BIT_HPP_INCLUDED 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/information/hartley.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2014 Erik Erlandson 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. (See 7 | // accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | 10 | #ifndef BOOST_UNITS_SYSTEMS_INFORMATION_HARTLEY_HPP_INCLUDED 11 | #define BOOST_UNITS_SYSTEMS_INFORMATION_HARTLEY_HPP_INCLUDED 12 | 13 | #include 14 | #include 15 | 16 | namespace boost { 17 | namespace units { 18 | namespace information { 19 | 20 | namespace hu { 21 | namespace hartley { 22 | typedef unit::type> info; 23 | } // namespace bit 24 | } // namespace hu 25 | 26 | BOOST_UNITS_STATIC_CONSTANT(hartley, hu::hartley::info); 27 | BOOST_UNITS_STATIC_CONSTANT(hartleys, hu::hartley::info); 28 | 29 | } // namespace information 30 | } // namespace units 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SYSTEMS_INFORMATION_HARTLEY_HPP_INCLUDED 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/information/nat.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2014 Erik Erlandson 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. (See 7 | // accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | 10 | #ifndef BOOST_UNITS_SYSTEMS_INFORMATION_NAT_HPP_INCLUDED 11 | #define BOOST_UNITS_SYSTEMS_INFORMATION_NAT_HPP_INCLUDED 12 | 13 | #include 14 | #include 15 | 16 | namespace boost { 17 | namespace units { 18 | namespace information { 19 | 20 | namespace hu { 21 | namespace nat { 22 | typedef unit::type> info; 23 | } // namespace bit 24 | } // namespace hu 25 | 26 | BOOST_UNITS_STATIC_CONSTANT(nat, hu::nat::info); 27 | BOOST_UNITS_STATIC_CONSTANT(nats, hu::nat::info); 28 | 29 | } // namespace information 30 | } // namespace units 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SYSTEMS_INFORMATION_NAT_HPP_INCLUDED 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/information/shannon.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2014 Erik Erlandson 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. (See 7 | // accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | 10 | #ifndef BOOST_UNITS_SYSTEMS_INFORMATION_SHANNON_HPP_INCLUDED 11 | #define BOOST_UNITS_SYSTEMS_INFORMATION_SHANNON_HPP_INCLUDED 12 | 13 | #include 14 | #include 15 | 16 | namespace boost { 17 | namespace units { 18 | namespace information { 19 | 20 | namespace hu { 21 | namespace shannon { 22 | typedef unit::type> info; 23 | } // namespace bit 24 | } // namespace hu 25 | 26 | BOOST_UNITS_STATIC_CONSTANT(shannon, hu::shannon::info); 27 | BOOST_UNITS_STATIC_CONSTANT(shannons, hu::shannon::info); 28 | 29 | } // namespace information 30 | } // namespace units 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SYSTEMS_INFORMATION_SHANNON_HPP_INCLUDED 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/absorbed_dose.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ABSORBED_DOSE_HPP 12 | #define BOOST_UNITS_SI_ABSORBED_DOSE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit absorbed_dose; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(gray,absorbed_dose); 26 | BOOST_UNITS_STATIC_CONSTANT(grays,absorbed_dose); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_ABSORBED_DOSE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/acceleration.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ACCELERATION_HPP 12 | #define BOOST_UNITS_SI_ACCELERATION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit acceleration; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(meter_per_second_squared,acceleration); 26 | BOOST_UNITS_STATIC_CONSTANT(meters_per_second_squared,acceleration); 27 | BOOST_UNITS_STATIC_CONSTANT(metre_per_second_squared,acceleration); 28 | BOOST_UNITS_STATIC_CONSTANT(metres_per_second_squared,acceleration); 29 | 30 | } // namespace si 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_SI_ACCELERATION_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/action.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ACTION_HPP 12 | #define BOOST_UNITS_SI_ACTION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit action; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_ACTION_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/activity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ACTIVITY_HPP 12 | #define BOOST_UNITS_SI_ACTIVITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit activity; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(becquerel,activity); 26 | BOOST_UNITS_STATIC_CONSTANT(becquerels,activity); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_ACTIVITY_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/amount.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_AMOUNT_HPP 12 | #define BOOST_UNITS_SI_AMOUNT_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit amount; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(mole,amount); 25 | BOOST_UNITS_STATIC_CONSTANT(moles,amount); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_AMOUNT_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/angular_acceleration.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ANGULAR_ACCELERATION_HPP 12 | #define BOOST_UNITS_SI_ANGULAR_ACCELERATION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit angular_acceleration; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_ANGULAR_ACCELERATION_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/angular_momentum.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ANGULAR_MOMENTUM_HPP 12 | #define BOOST_UNITS_SI_ANGULAR_MOMENTUM_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit angular_momentum; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_ANGULAR_MOMENTUM_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/angular_velocity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ANGULAR_VELOCITY_HPP 12 | #define BOOST_UNITS_SI_ANGULAR_VELOCITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit angular_velocity; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(radian_per_second,angular_velocity); 26 | BOOST_UNITS_STATIC_CONSTANT(radians_per_second,angular_velocity); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_ANGULAR_VELOCITY_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/area.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_AREA_HPP 12 | #define BOOST_UNITS_SI_AREA_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit area; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(square_meter,area); 26 | BOOST_UNITS_STATIC_CONSTANT(square_meters,area); 27 | BOOST_UNITS_STATIC_CONSTANT(square_metre,area); 28 | BOOST_UNITS_STATIC_CONSTANT(square_metres,area); 29 | 30 | } // namespace si 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_SI_AREA_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/capacitance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_CAPACITANCE_HPP 12 | #define BOOST_UNITS_SI_CAPACITANCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit capacitance; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(farad,capacitance); 26 | BOOST_UNITS_STATIC_CONSTANT(farads,capacitance); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_CAPACITANCE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/codata_constants.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_CODATA_CONSTANTS_HPP 12 | #define BOOST_UNITS_CODATA_CONSTANTS_HPP 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | #endif // BOOST_UNITS_CODATA_CONSTANTS_HPP 20 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/conductance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_CONDUCTANCE_HPP 12 | #define BOOST_UNITS_SI_CONDUCTANCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit conductance; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(siemen,conductance); 26 | BOOST_UNITS_STATIC_CONSTANT(siemens,conductance); 27 | BOOST_UNITS_STATIC_CONSTANT(mho,conductance); 28 | BOOST_UNITS_STATIC_CONSTANT(mhos,conductance); 29 | 30 | } // namespace si 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_SI_CONDUCTANCE_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/conductivity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_CONDUCTIVITY_HPP 12 | #define BOOST_UNITS_SI_CONDUCTIVITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit conductivity; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_CONDUCTIVITY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/current.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_CURRENT_HPP 12 | #define BOOST_UNITS_SI_CURRENT_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit current; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(ampere,current); 25 | BOOST_UNITS_STATIC_CONSTANT(amperes,current); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_CURRENT_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/dimensionless.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_DIMENSIONLESS_HPP 12 | #define BOOST_UNITS_SI_DIMENSIONLESS_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | BOOST_UNITS_STATIC_CONSTANT(si_dimensionless,dimensionless); 23 | 24 | } // namespace si 25 | 26 | } // namespace units 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_UNITS_SI_DIMENSIONLESS_HPP 31 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/dose_equivalent.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_DOSE_EQUIVALENT_HPP 12 | #define BOOST_UNITS_SI_DOSE_EQUIVALENT_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit dose_equivalent; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(sievert,dose_equivalent); 26 | BOOST_UNITS_STATIC_CONSTANT(sieverts,dose_equivalent); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_DOSE_EQUIVALENT_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/dynamic_viscosity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_DYNAMIC_VISCOSITY_HPP 12 | #define BOOST_UNITS_SI_DYNAMIC_VISCOSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit dynamic_viscosity; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_DYNAMIC_VISCOSITY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/electric_charge.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ELECTRIC_CHARGE_HPP 12 | #define BOOST_UNITS_SI_ELECTRIC_CHARGE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit electric_charge; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(coulomb,electric_charge); 26 | BOOST_UNITS_STATIC_CONSTANT(coulombs,electric_charge); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_ELECTRIC_CHARGE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/electric_potential.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ELECTRIC_POTENTIAL_HPP 12 | #define BOOST_UNITS_SI_ELECTRIC_POTENTIAL_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit electric_potential; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(volt,electric_potential); 26 | BOOST_UNITS_STATIC_CONSTANT(volts,electric_potential); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_ELECTRIC_POTENTIAL_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/energy.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ENERGY_HPP 12 | #define BOOST_UNITS_SI_ENERGY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit energy; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(joule,energy); 26 | BOOST_UNITS_STATIC_CONSTANT(joules,energy); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_ENERGY_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/force.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_FORCE_HPP 12 | #define BOOST_UNITS_SI_FORCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit force; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(newton,force); 26 | BOOST_UNITS_STATIC_CONSTANT(newtons,force); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_FORCE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/frequency.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_FREQUENCY_HPP 12 | #define BOOST_UNITS_SI_FREQUENCY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit frequency; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(hertz,frequency); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_FREQUENCY_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/illuminance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_ILLUMINANCE_HPP 12 | #define BOOST_UNITS_SI_ILLUMINANCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit illuminance; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(lux,illuminance); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_ILLUMINANCE_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/impedance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_IMPEDANCE_HPP 12 | #define BOOST_UNITS_SI_IMPEDANCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit impedance; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_IMPEDANCE_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/inductance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_INDUCTANCE_HPP 12 | #define BOOST_UNITS_SI_INDUCTANCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit inductance; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(henry,inductance); 26 | BOOST_UNITS_STATIC_CONSTANT(henrys,inductance); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_INDUCTANCE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/kinematic_viscosity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_KINEMATIC_VISCOSITY_HPP 12 | #define BOOST_UNITS_SI_KINEMATIC_VISCOSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit kinematic_viscosity; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_KINEMATIC_VISCOSITY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/length.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_LENGTH_HPP 12 | #define BOOST_UNITS_SI_LENGTH_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit length; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(meter,length); 25 | BOOST_UNITS_STATIC_CONSTANT(meters,length); 26 | BOOST_UNITS_STATIC_CONSTANT(metre,length); 27 | BOOST_UNITS_STATIC_CONSTANT(metres,length); 28 | 29 | } // namespace si 30 | 31 | } // namespace units 32 | 33 | } // namespace boost 34 | 35 | #endif // BOOST_UNITS_SI_LENGTH_HPP 36 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/luminous_flux.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_LUMINOUS_FLUX_HPP 12 | #define BOOST_UNITS_SI_LUMINOUS_FLUX_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit luminous_flux; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(lumen,luminous_flux); 26 | BOOST_UNITS_STATIC_CONSTANT(lumens,luminous_flux); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_LUMINOUS_FLUX_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/luminous_intensity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_LUMINOUS_INTENSITY_HPP 12 | #define BOOST_UNITS_SI_LUMINOUS_INTENSITY_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit luminous_intensity; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(candela,luminous_intensity); 25 | BOOST_UNITS_STATIC_CONSTANT(candelas,luminous_intensity); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_LUMINOUS_INTENSITY_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/magnetic_field_intensity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_MAGNETIC_FIELD_INTENSITY_HPP 12 | #define BOOST_UNITS_SI_MAGNETIC_FIELD_INTENSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit magnetic_field_intensity; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_MAGNETIC_FIELD_INTENSITY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/magnetic_flux.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_MAGNETIC_FLUX_HPP 12 | #define BOOST_UNITS_SI_MAGNETIC_FLUX_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit magnetic_flux; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(weber,magnetic_flux); 26 | BOOST_UNITS_STATIC_CONSTANT(webers,magnetic_flux); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_MAGNETIC_FLUX_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/magnetic_flux_density.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_MAGNETIC_FLUX_DENSITY_HPP 12 | #define BOOST_UNITS_SI_MAGNETIC_FLUX_DENSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit magnetic_flux_density; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(tesla,magnetic_flux_density); 26 | BOOST_UNITS_STATIC_CONSTANT(teslas,magnetic_flux_density); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_MAGNETIC_FLUX_DENSITY_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/mass.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_MASS_HPP 12 | #define BOOST_UNITS_SI_MASS_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit mass; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(kilogram,mass); 25 | BOOST_UNITS_STATIC_CONSTANT(kilograms,mass); 26 | BOOST_UNITS_STATIC_CONSTANT(kilogramme,mass); 27 | BOOST_UNITS_STATIC_CONSTANT(kilogrammes,mass); 28 | 29 | } // namespace si 30 | 31 | } // namespace units 32 | 33 | } // namespace boost 34 | 35 | #endif // BOOST_UNITS_SI_MASS_HPP 36 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/mass_density.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_MASS_DENSITY_HPP 12 | #define BOOST_UNITS_SI_MASS_DENSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit mass_density; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(kilogram_per_cubic_meter,mass_density); 26 | BOOST_UNITS_STATIC_CONSTANT(kilograms_per_cubic_meter,mass_density); 27 | BOOST_UNITS_STATIC_CONSTANT(kilogramme_per_cubic_metre,mass_density); 28 | BOOST_UNITS_STATIC_CONSTANT(kilogrammes_per_cubic_metre,mass_density); 29 | 30 | } // namespace si 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_SI_MASS_DENSITY_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/moment_of_inertia.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_MOMENT_OF_INERTIA_HPP 12 | #define BOOST_UNITS_SI_MOMENT_OF_INERTIA_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit moment_of_inertia; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_MOMENT_OF_INERTIA_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/momentum.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_MOMENTUM_HPP 12 | #define BOOST_UNITS_SI_MOMENTUM_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit momentum; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_MOMENTUM_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/permeability.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_PERMEABILITY_HPP 12 | #define BOOST_UNITS_SI_PERMEABILITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit permeability; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_PERMEABILITY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/permittivity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_PERMITTIVITY_HPP 12 | #define BOOST_UNITS_SI_PERMITTIVITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit permittivity; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_PERMITTIVITY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/plane_angle.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_PLANE_ANGLE_HPP 12 | #define BOOST_UNITS_SI_PLANE_ANGLE_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit plane_angle; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(radian,plane_angle); 25 | BOOST_UNITS_STATIC_CONSTANT(radians,plane_angle); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_PLANE_ANGLE_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/power.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_POWER_HPP 12 | #define BOOST_UNITS_SI_POWER_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit power; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(watt,power); 26 | BOOST_UNITS_STATIC_CONSTANT(watts,power); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_POWER_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/reluctance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_RELUCTANCE_HPP 12 | #define BOOST_UNITS_SI_RELUCTANCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit reluctance; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_RELUCTANCE_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/resistance.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_RESISTANCE_HPP 12 | #define BOOST_UNITS_SI_RESISTANCE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit resistance; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(ohm,resistance); 26 | BOOST_UNITS_STATIC_CONSTANT(ohms,resistance); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_RESISTANCE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/resistivity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_RESISTIVITY_HPP 12 | #define BOOST_UNITS_SI_RESISTIVITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit resistivity; 24 | 25 | } // namespace si 26 | 27 | } // namespace units 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_UNITS_SI_RESISTIVITY_HPP 32 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/solid_angle.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_SOLID_ANGLE_HPP 12 | #define BOOST_UNITS_SI_SOLID_ANGLE_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit solid_angle; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(steradian,solid_angle); 25 | BOOST_UNITS_STATIC_CONSTANT(steradians,solid_angle); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_SOLID_ANGLE_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/surface_density.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_SURFACE_DENSITY_HPP 12 | #define BOOST_UNITS_SI_SURFACE_DENSITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit surface_density; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(kilogram_per_square_meter,surface_density); 26 | BOOST_UNITS_STATIC_CONSTANT(kilograms_per_square_meter,surface_density); 27 | BOOST_UNITS_STATIC_CONSTANT(kilogramme_per_square_metre,surface_density); 28 | BOOST_UNITS_STATIC_CONSTANT(kilogrammes_per_square_metre,surface_density); 29 | 30 | } // namespace si 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_SI_SURFACE_DENSITY_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/surface_tension.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_SURFACE_TENSION_HPP 12 | #define BOOST_UNITS_SI_SURFACE_TENSION_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit surface_tension; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(newton_per_meter,surface_tension); 26 | BOOST_UNITS_STATIC_CONSTANT(newtons_per_meter,surface_tension); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_SURFACE_TENSION_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/temperature.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_TEMPERATURE_HPP 12 | #define BOOST_UNITS_SI_TEMPERATURE_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit temperature; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(kelvin,temperature); 25 | BOOST_UNITS_STATIC_CONSTANT(kelvins,temperature); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_TEMPERATURE_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/time.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_TIME_HPP 12 | #define BOOST_UNITS_SI_TIME_HPP 13 | 14 | #include 15 | 16 | namespace boost { 17 | 18 | namespace units { 19 | 20 | namespace si { 21 | 22 | typedef unit time; 23 | 24 | BOOST_UNITS_STATIC_CONSTANT(second,time); 25 | BOOST_UNITS_STATIC_CONSTANT(seconds,time); 26 | 27 | } // namespace si 28 | 29 | } // namespace units 30 | 31 | } // namespace boost 32 | 33 | #endif // BOOST_UNITS_SI_TIME_HPP 34 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/torque.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_TORQUE_HPP 12 | #define BOOST_UNITS_SI_TORQUE_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit torque; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(newton_meter,torque); 26 | BOOST_UNITS_STATIC_CONSTANT(newton_meters,torque); 27 | 28 | } // namespace si 29 | 30 | } // namespace units 31 | 32 | } // namespace boost 33 | 34 | #endif // BOOST_UNITS_SI_TORQUE_HPP 35 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/velocity.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_VELOCITY_HPP 12 | #define BOOST_UNITS_SI_VELOCITY_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit velocity; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(meter_per_second,velocity); 26 | BOOST_UNITS_STATIC_CONSTANT(meters_per_second,velocity); 27 | BOOST_UNITS_STATIC_CONSTANT(metre_per_second,velocity); 28 | BOOST_UNITS_STATIC_CONSTANT(metres_per_second,velocity); 29 | 30 | } // namespace si 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_SI_VELOCITY_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/volume.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_VOLUME_HPP 12 | #define BOOST_UNITS_SI_VOLUME_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit volume; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(cubic_meter,volume); 26 | BOOST_UNITS_STATIC_CONSTANT(cubic_meters,volume); 27 | BOOST_UNITS_STATIC_CONSTANT(cubic_metre,volume); 28 | BOOST_UNITS_STATIC_CONSTANT(cubic_metres,volume); 29 | 30 | } // namespace si 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_SI_VOLUME_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/si/wavenumber.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_SI_WAVENUMBER_HPP 12 | #define BOOST_UNITS_SI_WAVENUMBER_HPP 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | namespace units { 20 | 21 | namespace si { 22 | 23 | typedef unit wavenumber; 24 | 25 | BOOST_UNITS_STATIC_CONSTANT(reciprocal_meter,wavenumber); 26 | BOOST_UNITS_STATIC_CONSTANT(reciprocal_meters,wavenumber); 27 | BOOST_UNITS_STATIC_CONSTANT(reciprocal_metre,wavenumber); 28 | BOOST_UNITS_STATIC_CONSTANT(reciprocal_metres,wavenumber); 29 | 30 | } // namespace si 31 | 32 | } // namespace units 33 | 34 | } // namespace boost 35 | 36 | #endif // BOOST_UNITS_SI_WAVENUMBER_HPP 37 | -------------------------------------------------------------------------------- /include/boost/units/systems/temperature/celsius.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #ifndef BOOST_UNITS_TEMPERATURE_CELSIUS_HPP 12 | #define BOOST_UNITS_TEMPERATURE_CELSIUS_HPP 13 | 14 | #include 15 | 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | namespace boost { 22 | 23 | namespace units { 24 | 25 | namespace celsius { 26 | 27 | typedef make_system::type system; 28 | 29 | typedef unit temperature; 30 | 31 | BOOST_UNITS_STATIC_CONSTANT(degree,temperature); 32 | BOOST_UNITS_STATIC_CONSTANT(degrees,temperature); 33 | 34 | } // namespace celsius 35 | 36 | } // namespace units 37 | 38 | } // namespace boost 39 | 40 | #endif // BOOST_UNITS_TEMPERATURE_CELSIUS_HPP 41 | -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | Automatic redirection failed, please go to 7 | ../../doc/html/boost_units.html 8 |
9 | 10 | Boost.Units - A C++ library for zero-overhead dimensional analysis and 11 | unit/quantity manipulation and conversion
12 |
13 | Copyright (C) 2003-2008 Matthias Christian Schabel
14 | Copyright (C) 2007-2008 Steven Watanabe
15 |
16 | Distributed under the Boost Software License, Version 1.0. (See 17 | accompanying file LICENSE_1_0.txt or copy at 18 | http://www.boost.org/LICENSE_1_0.txt)
19 |
20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /meta/libraries.json: -------------------------------------------------------------------------------- 1 | { 2 | "key": "units", 3 | "name": "Units", 4 | "authors": [ 5 | "Matthias Schabel", 6 | "Steven Watanabe" 7 | ], 8 | "description": "Zero-overhead dimensional analysis and unit/quantity manipulation and conversion.", 9 | "category": [ 10 | "Domain" 11 | ], 12 | "maintainers": [ 13 | "Jürgen Hunold ", 14 | "Steven Watanabe " 15 | ] 16 | } 17 | -------------------------------------------------------------------------------- /test/fail_add_temperature.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_add_temperature.cpp 15 | 16 | \details 17 | Verify that adding two absolute temeratures fails miserably. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | #include 27 | 28 | namespace bu = boost::units; 29 | 30 | int main(int,char *[]) 31 | { 32 | 33 | bu::quantity > q(2.0 * bu::absolute()); 34 | 35 | q += q; 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /test/fail_adl_detail.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_adl_detail.cpp 15 | 16 | \details 17 | make sure that namespace detail is not pulled in by ADL. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | namespace boost { 30 | namespace units { 31 | namespace detail { 32 | 33 | template 34 | void this_function_should_not_be_found_by_adl(const T&) {}; 35 | 36 | } 37 | } 38 | } 39 | 40 | int main(int argc,char *argv[]) 41 | { 42 | 43 | bu::quantity q; 44 | 45 | this_function_should_not_be_found_by_adl(q); 46 | 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /test/fail_base_dimension.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_base_dimension.cpp 15 | 16 | \details 17 | make sure that trying to use the same ordinal for multiple 18 | base dimensions fails. 19 | 20 | Output: 21 | @verbatim 22 | @endverbatim 23 | **/ 24 | 25 | #include 26 | 27 | struct dim1 : boost::units::base_dimension {}; 28 | struct dim2 : boost::units::base_dimension {}; 29 | 30 | int main() 31 | { 32 | } 33 | -------------------------------------------------------------------------------- /test/fail_implicit_conversion.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_implicit_conversion.cpp 15 | 16 | \details 17 | Test implicit conversions for quantity. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | #include 27 | 28 | namespace bu = boost::units; 29 | 30 | int main(int,char *[]) 31 | { 32 | const bu::quantity T1(2.0 * bu::si::meters); 33 | const bu::quantity T2 = T1; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /test/fail_quantity_add.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_add.cpp 15 | 16 | \details 17 | Test addition of quantities with different dimensions. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | 2.0 * bu::si::seconds + 2.0 * bu::si::meters; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_quantity_add_assign.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_add_assign.cpp 15 | 16 | \details 17 | Test += of quantity from different dimensions. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int,char *[]) 30 | { 31 | 32 | bu::quantity T1; 33 | T1 += 2.0 * bu::si::seconds; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /test/fail_quantity_assign.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_assign.cpp 15 | 16 | \details 17 | Test assignment of quantity from different dimensions. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | const bu::quantity T1; 33 | T1 = 2.0 * bu::si::seconds; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /test/fail_quantity_construct.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_construct.cpp 15 | 16 | \details 17 | Test construction of quantity from different dimensions. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int,char *[]) 30 | { 31 | 32 | const bu::quantity T1(2.0 * bu::si::seconds); 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_quantity_non_unit.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2008 Steven Watanabe 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. (See 7 | // accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | 10 | /** 11 | \file 12 | 13 | \brief fail_quantity_non_unit.cpp 14 | 15 | \details 16 | 17 | Make sure that trying to use a base_unit as though 18 | it were a unit fails. 19 | 20 | Output: 21 | @verbatim 22 | @endverbatim 23 | **/ 24 | 25 | #include 26 | #include 27 | 28 | namespace bu = boost::units; 29 | 30 | int main(int,char *[]) 31 | { 32 | 33 | bu::quantity q; 34 | 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /test/fail_quantity_scalar_add.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_scalar_add.cpp 15 | 16 | \details 17 | Test addition of quantity and scalar. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | 2.0 * bu::si::meters + 2.0; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_quantity_scalar_sub.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_scalar_sub.cpp 15 | 16 | \details 17 | Test subtraction of quantity and scalar. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | 2.0 * bu::si::meters - 2.0; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_quantity_sub_assign.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_sub_assign.cpp 15 | 16 | \details 17 | Test -= of quantity from different dimensions. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int,char *[]) 30 | { 31 | 32 | bu::quantity T1; 33 | T1 -= 2.0 * bu::si::seconds; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /test/fail_quantity_subtract.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_subtract.cpp 15 | 16 | \details 17 | Test subtraction of quantities with different dimensions. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | 2.0 * bu::si::seconds - 2.0 * bu::si::meters; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_quantity_unit_add.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_unit_add.cpp 15 | 16 | \details 17 | Test addition of quantity and unit. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | 2.0 * bu::si::meters + bu::si::meters; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_quantity_unit_subtract.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_quantity_unit_subtract.cpp 15 | 16 | \details 17 | Test subtraction of quantity and unit. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | 2.0 * bu::si::meters - bu::si::meters; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_scalar_quantity_add.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_scalar_quantity_add.cpp 15 | 16 | \details 17 | Test addition of scalar and quantity. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | 2.0 + 2.0 * bu::si::meters; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_scalar_quantity_sub.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_scalar_quantity_sub.cpp 15 | 16 | \details 17 | Test subtraction of scalar and quantity. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | 2.0 - 2.0 * bu::si::meters; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_unit_quantity_add.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_unit_quantity_add.cpp 15 | 16 | \details 17 | Test addition of unit and quantity. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | bu::si::meters + 2.0 * bu::si::meters; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/fail_unit_quantity_subtract.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief fail_unit_quantity_add.cpp 15 | 16 | \details 17 | Test addition of unit and quantity. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | namespace bu = boost::units; 28 | 29 | int main(int argc,char *argv[]) 30 | { 31 | 32 | bu::si::meters + 2.0 * bu::si::meters; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /test/test_base_dimension.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief test_base_dimension.cpp 15 | 16 | \details 17 | Test base_dimension class. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | 26 | struct dimension : boost::units::base_dimension { 27 | typedef boost::units::base_dimension base; 28 | }; 29 | 30 | int main() { 31 | } 32 | -------------------------------------------------------------------------------- /test/test_close.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2021 Glen Joseph Fernandes 3 | (glenjofe@gmail.com) 4 | 5 | Distributed under the Boost Software License, Version 1.0. 6 | (http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | #ifndef BOOST_UNITS_TEST_CLOSE_HPP 9 | #define BOOST_UNITS_TEST_CLOSE_HPP 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | /* 17 | Provide a predicate for BOOST_TEST_WITH that is equivalent to 18 | what was provided by the previous test framework. 19 | */ 20 | class close_to { 21 | public: 22 | explicit close_to(double f) 23 | : f_(f) { } 24 | 25 | bool operator()(double l, double r) const { 26 | return std::abs(l - r) <= 27 | (std::max)(f_ * (std::max)(std::abs(l), std::abs(r)), 0.); 28 | } 29 | 30 | private: 31 | double f_; 32 | }; 33 | 34 | #define BOOST_UNITS_TEST_CLOSE(l,r,f) BOOST_TEST_WITH((l),(r),close_to((f))) 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /test/test_dimensionless_ice1.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | void foo() 16 | { 17 | BOOST_CONSTEXPR_OR_CONST boost::units::quantity d = boost::units::quantity< boost::units::si::dimensionless >(); 18 | boost::ignore_unused(d); 19 | } 20 | -------------------------------------------------------------------------------- /test/test_dimensionless_ice2.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | void foo() 16 | { 17 | BOOST_CONSTEXPR_OR_CONST boost::units::quantity d(1.0 * boost::units::si::meters / boost::units::cgs::centimeters); 18 | } 19 | -------------------------------------------------------------------------------- /test/test_mixed_value_types.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | namespace bu = boost::units; 16 | 17 | int main() { 18 | bu::quantity q1; 19 | BOOST_CONSTEXPR_OR_CONST bu::quantity q2; 20 | q1 + q2; 21 | q1 -= q2; 22 | } 23 | -------------------------------------------------------------------------------- /test/test_negative_denominator.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief test_negative_denominator.cpp 15 | 16 | \details 17 | Test negative denominator for static_rational class. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | 26 | #include 27 | #include 28 | 29 | BOOST_MPL_ASSERT((boost::is_same::type, boost::units::static_rational<2, -1>::type>)); 30 | 31 | int main() { 32 | } 33 | -------------------------------------------------------------------------------- /test/test_reduce_unit.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | /** 12 | \file 13 | 14 | \brief test_reduce_unit.cpp 15 | 16 | \details 17 | Test that reduce_unit works correctly by itself to try to isolate problems. 18 | 19 | Output: 20 | @verbatim 21 | @endverbatim 22 | **/ 23 | 24 | #include 25 | #include 26 | 27 | #include 28 | #include 29 | 30 | BOOST_MPL_ASSERT((boost::is_same::type, boost::units::si::kelvin_base_unit::unit_type>)); 31 | -------------------------------------------------------------------------------- /test_headers/main.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | int main() { 12 | } 13 | -------------------------------------------------------------------------------- /test_headers/test.cpp: -------------------------------------------------------------------------------- 1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and 2 | // unit/quantity manipulation and conversion 3 | // 4 | // Copyright (C) 2003-2008 Matthias Christian Schabel 5 | // Copyright (C) 2007-2008 Steven Watanabe 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | 11 | #define BOOST_UNITS_STRINGIZE_IMPL(x) #x 12 | #define BOOST_UNITS_STRINGIZE(x) BOOST_UNITS_STRINGIZE_IMPL(x) 13 | 14 | #define BOOST_UNITS_HEADER BOOST_UNITS_STRINGIZE(BOOST_UNITS_HEADER_NAME) 15 | 16 | #include BOOST_UNITS_HEADER 17 | #include BOOST_UNITS_HEADER 18 | 19 | int main() {} 20 | --------------------------------------------------------------------------------