mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-07-30 02:17:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

base_dimension is provided as a const& to the exp type

Browse Source
This commit is contained in:
Mateusz Pusz
2019-09-06 10:16:19 +02:00
parent 33b6fa9f3f
commit 3bcd80681e
20 changed files with 99 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
src/include/units/dimension.h
View File

@ -27,23 +27,42 @@
namespace std::experimental::units {
// dim_id
struct base_dimension {
const char* name;
};
template<int UniqueValue>
using dim_id = std::integral_constant<int, UniqueValue>;
constexpr bool operator==(const base_dimension& lhs, const base_dimension& rhs)
{
const char* p1 = lhs.name;
const char* p2 = rhs.name;
for(; (*p1 != '\0') && (*p2 != '\0'); ++p1, (void)++p2) {
if(*p1 != *p2) return false;
}
return *p1 == *p2;
}
// dim_id_less
constexpr bool operator<(const base_dimension& lhs, const base_dimension& rhs)
{
const char* p1 = lhs.name;
const char* p2 = rhs.name;
for(; (*p1 != '\0') && (*p2 != '\0'); ++p1, (void)++p2) {
if(*p1 < *p2) return true;
if(*p2 < *p1) return false;
}
return (*p1 == '\0') && (*p2 != '\0');
}
template<typename D1, typename D2>
struct dim_id_less : std::bool_constant<D1::value < D2::value> {
// base_dimension_less
template<const base_dimension& D1, const base_dimension& D2>
struct base_dimension_less : std::bool_constant<D1 < D2> {
};
// exp
template<typename BaseDimension, int Value> // todo: to be replaced with fixed_string when supported by the compilers
// template<fixed_string BaseDimension, int Value>
template<const base_dimension& BaseDimension, int Value>
struct exp {
using dimension = BaseDimension;
static constexpr const base_dimension& dimension = BaseDimension;
static constexpr int value = Value;
};
@ -52,8 +71,8 @@ namespace std::experimental::units {
template<typename T>
inline constexpr bool is_exp = false;
template<typename BaseDim, int Value>
inline constexpr bool is_exp<exp<BaseDim, Value>> = true;
template<const base_dimension& BaseDimension, int Value>
inline constexpr bool is_exp<exp<BaseDimension, Value>> = true;
} // namespace detail
template<typename T>
@ -62,7 +81,7 @@ namespace std::experimental::units {
// exp_dim_id_less
template<Exponent E1, Exponent E2>
struct exp_dim_id_less : dim_id_less<typename E1::dimension, typename E2::dimension> {
struct exp_less : base_dimension_less<E1::dimension, E2::dimension> {
};
// exp_invert
@ -70,7 +89,7 @@ namespace std::experimental::units {
template<Exponent E>
struct exp_invert;
template<typename BaseDimension, int Value>
template<const base_dimension& BaseDimension, int Value>
struct exp_invert<exp<BaseDimension, Value>> {
using type = exp<BaseDimension, -Value>;
};
@ -138,7 +157,7 @@ namespace std::experimental::units {
using type = conditional<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
};
template<typename D, int V1, int V2, typename... ERest>
template<const base_dimension& D, int V1, int V2, typename... ERest>
struct dim_consolidate<dimension<exp<D, V1>, exp<D, V2>, ERest...>> {
using type = conditional<V1 + V2 == 0, dim_consolidate_t<dimension<ERest...>>,
dim_consolidate_t<dimension<exp<D, V1 + V2>, ERest...>>>;
@ -148,7 +167,7 @@ namespace std::experimental::units {
template<Exponent... Es>
struct make_dimension {
using type = detail::dim_consolidate_t<type_list_sort<dimension<Es...>, exp_dim_id_less>>;
using type = detail::dim_consolidate_t<type_list_sort<dimension<Es...>, exp_less>>;
};
template<Exponent... Es>
@ -156,7 +175,7 @@ namespace std::experimental::units {
template<Dimension D1, Dimension D2>
struct merge_dimension {
using type = detail::dim_consolidate_t<type_list_merge_sorted<D1, D2, exp_dim_id_less>>;
using type = detail::dim_consolidate_t<type_list_merge_sorted<D1, D2, exp_less>>;
};
template<Dimension D1, Dimension D2>

16
src/include/units/base_dimensions.h → src/include/units/dimensions/base_dimensions.h
View File

@ -26,14 +26,12 @@
namespace std::experimental::units {
// todo: to be replaced with fixed_string when supported by the compilers
struct base_dim_length : dim_id<0> {};
struct base_dim_mass : dim_id<1> {};
struct base_dim_time : dim_id<2> {};
struct base_dim_current : dim_id<3> {};
struct base_dim_temperature : dim_id<4> {};
struct base_dim_substance : dim_id<5> {};
struct base_dim_luminous_intensity : dim_id<6> {};
inline constexpr base_dimension base_dim_length{"length"};
inline constexpr base_dimension base_dim_mass{"mass"};
inline constexpr base_dimension base_dim_time{"time"};
inline constexpr base_dimension base_dim_current{"current"};
inline constexpr base_dimension base_dim_temperature{"temperature"};
inline constexpr base_dimension base_dim_substance{"substance"};
inline constexpr base_dimension base_dim_luminous_intensity{"luminous intensity"};
} // namespace std::experimental::units

2
src/include/units/dimensions/capacitance.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/dimensions/electric_charge.h>
#include <units/dimensions/voltage.h>

2
src/include/units/dimensions/current.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/quantity.h>
namespace std::experimental::units {

2
src/include/units/dimensions/electric_charge.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/dimensions/time.h>
#include <units/dimensions/current.h>

2
src/include/units/dimensions/energy.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/dimensions/force.h>
#include <units/dimensions/pressure.h>

2
src/include/units/dimensions/force.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/dimensions/mass.h>
#include <units/dimensions/length.h>
#include <units/dimensions/time.h>

2
src/include/units/dimensions/frequency.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/dimensions/time.h>
namespace std::experimental::units {

2
src/include/units/dimensions/length.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/quantity.h>
namespace std::experimental::units {

2
src/include/units/dimensions/luminous_intensity.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/quantity.h>
namespace std::experimental::units {

2
src/include/units/dimensions/mass.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/quantity.h>
namespace std::experimental::units {

2
src/include/units/dimensions/power.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/dimensions/energy.h>
namespace std::experimental::units {

2
src/include/units/dimensions/pressure.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/dimensions/force.h>
namespace std::experimental::units {

2
src/include/units/dimensions/substance.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/quantity.h>
namespace std::experimental::units {

2
src/include/units/dimensions/temperature.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/quantity.h>
namespace std::experimental::units {

2
src/include/units/dimensions/time.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/quantity.h>
namespace std::experimental::units {

2
src/include/units/dimensions/voltage.h
View File

@ -22,7 +22,7 @@
#pragma once
#include <units/base_dimensions.h>
#include <units/dimensions/base_dimensions.h>
#include <units/dimensions/power.h>
#include <units/dimensions/current.h>
#include <units/dimensions/energy.h>

12
src/include/units/unit.h
View File

@ -63,18 +63,18 @@ namespace std::experimental::units {
template<typename E, typename... Rest>
struct get_unit_base_dim<dimension<E, Rest...>> {
static_assert(sizeof...(Rest) == 0, "Base unit expected");
using dimension = E::dimension;
static constexpr const base_dimension& dimension = E::dimension;
};
template<typename BaseDimension, typename... Us>
template<const base_dimension& BaseDimension, typename... Us>
struct get_ratio {
using ratio = ::std::experimental::units::ratio<1>;
};
template<typename BaseDimension, typename U, typename... Rest>
template<const base_dimension& BaseDimension, typename U, typename... Rest>
struct get_ratio<BaseDimension, U, Rest...> {
using unit_base_dim = get_unit_base_dim<typename U::dimension::base_type>::dimension;
using ratio = conditional<unit_base_dim::value == BaseDimension::value, typename U::ratio,
static constexpr const base_dimension& unit_base_dim = get_unit_base_dim<typename U::dimension::base_type>::dimension;
using ratio = conditional<&unit_base_dim == &BaseDimension, typename U::ratio,
typename get_ratio<BaseDimension, Rest...>::ratio>;
};
@ -105,7 +105,7 @@ namespace std::experimental::units {
template<typename E, typename... Rest, typename... Us>
struct derived_ratio<dimension<E, Rest...>, Us...> {
using rest_ratio = derived_ratio<dimension<Rest...>, Us...>::ratio;
using e_ratio = get_ratio<typename E::dimension, Us...>::ratio;
using e_ratio = get_ratio<E::dimension, Us...>::ratio;
using ratio = ratio_op<rest_ratio, E::value, e_ratio>::ratio;
};

50
test/unit_test/test_dimension.cpp
View File

@ -27,46 +27,48 @@ using namespace std::experimental::units;
namespace {
template<int Id, int Value>
using e = exp<dim_id<Id>, Value>;
inline constexpr base_dimension d0{"d0"};
inline constexpr base_dimension d1{"d1"};
inline constexpr base_dimension d2{"d2"};
inline constexpr base_dimension d3{"d3"};
// exp_invert
static_assert(std::is_same_v<exp_invert_t<e<0, 1>>, e<0, -1>>);
static_assert(std::is_same_v<exp_invert_t<e<1, -1>>, e<1, 1>>);
static_assert(std::is_same_v<exp_invert_t<exp<d0, 1>>, exp<d0, -1>>);
static_assert(std::is_same_v<exp_invert_t<exp<d1, -1>>, exp<d1, 1>>);
// make_dimension
static_assert(std::is_same_v<make_dimension_t<e<0, 1>>, dimension<e<0, 1>>>);
static_assert(std::is_same_v<make_dimension_t<e<0, 1>, e<1, 1>>, dimension<e<0, 1>, e<1, 1>>>);
static_assert(std::is_same_v<make_dimension_t<e<1, 1>, e<0, 1>>, dimension<e<0, 1>, e<1, 1>>>);
static_assert(std::is_same_v<make_dimension_t<e<1, 1>, e<1, 1>>, dimension<e<1, 2>>>);
static_assert(std::is_same_v<make_dimension_t<e<1, 1>, e<1, -1>>, dimension<>>);
static_assert(std::is_same_v<make_dimension_t<exp<d0, 1>>, dimension<exp<d0, 1>>>);
static_assert(std::is_same_v<make_dimension_t<exp<d0, 1>, exp<d1, 1>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
static_assert(std::is_same_v<make_dimension_t<exp<d1, 1>, exp<d0, 1>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
static_assert(std::is_same_v<make_dimension_t<exp<d1, 1>, exp<d1, 1>>, dimension<exp<d1, 2>>>);
static_assert(std::is_same_v<make_dimension_t<exp<d1, 1>, exp<d1, -1>>, dimension<>>);
static_assert(std::is_same_v<make_dimension_t<e<0, 1>, e<1, 1>, e<0, 1>, e<1, 1>>, dimension<e<0, 2>, e<1, 2>>>);
static_assert(std::is_same_v<make_dimension_t<exp<d0, 1>, exp<d1, 1>, exp<d0, 1>, exp<d1, 1>>, dimension<exp<d0, 2>, exp<d1, 2>>>);
static_assert(
std::is_same_v<make_dimension_t<e<0, -1>, e<1, -1>, e<0, -1>, e<1, -1>>, dimension<e<0, -2>, e<1, -2>>>);
std::is_same_v<make_dimension_t<exp<d0, -1>, exp<d1, -1>, exp<d0, -1>, exp<d1, -1>>, dimension<exp<d0, -2>, exp<d1, -2>>>);
static_assert(std::is_same_v<make_dimension_t<e<0, 1>, e<1, 1>, e<1, -1>>, dimension<e<0, 1>>>);
static_assert(std::is_same_v<make_dimension_t<e<0, 1>, e<0, -1>, e<1, 1>>, dimension<e<1, 1>>>);
static_assert(std::is_same_v<make_dimension_t<e<0, 1>, e<1, 1>, e<0, -1>>, dimension<e<1, 1>>>);
static_assert(std::is_same_v<make_dimension_t<e<0, 1>, e<1, 1>, e<0, -1>, e<1, -1>>, dimension<>>);
static_assert(std::is_same_v<make_dimension_t<exp<d0, 1>, exp<d1, 1>, exp<d1, -1>>, dimension<exp<d0, 1>>>);
static_assert(std::is_same_v<make_dimension_t<exp<d0, 1>, exp<d0, -1>, exp<d1, 1>>, dimension<exp<d1, 1>>>);
static_assert(std::is_same_v<make_dimension_t<exp<d0, 1>, exp<d1, 1>, exp<d0, -1>>, dimension<exp<d1, 1>>>);
static_assert(std::is_same_v<make_dimension_t<exp<d0, 1>, exp<d1, 1>, exp<d0, -1>, exp<d1, -1>>, dimension<>>);
// dimension_multiply
static_assert(
std::is_same_v<dimension_multiply_t<dimension<e<0, 1>>, dimension<e<1, 1>>>, dimension<e<0, 1>, e<1, 1>>>);
static_assert(std::is_same_v<dimension_multiply_t<dimension<e<0, 1>, e<1, 1>, e<2, 1>>, dimension<e<3, 1>>>,
dimension<e<0, 1>, e<1, 1>, e<2, 1>, e<3, 1>>>);
static_assert(std::is_same_v<dimension_multiply_t<dimension<e<0, 1>, e<1, 1>, e<2, 1>>, dimension<e<1, 1>>>,
dimension<e<0, 1>, e<1, 2>, e<2, 1>>>);
static_assert(std::is_same_v<dimension_multiply_t<dimension<e<0, 1>, e<1, 1>, e<2, 1>>, dimension<e<1, -1>>>,
dimension<e<0, 1>, e<2, 1>>>);
std::is_same_v<dimension_multiply_t<dimension<exp<d0, 1>>, dimension<exp<d1, 1>>>, dimension<exp<d0, 1>, exp<d1, 1>>>);
static_assert(std::is_same_v<dimension_multiply_t<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d3, 1>>>,
dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>, exp<d3, 1>>>);
static_assert(std::is_same_v<dimension_multiply_t<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d1, 1>>>,
dimension<exp<d0, 1>, exp<d1, 2>, exp<d2, 1>>>);
static_assert(std::is_same_v<dimension_multiply_t<dimension<exp<d0, 1>, exp<d1, 1>, exp<d2, 1>>, dimension<exp<d1, -1>>>,
dimension<exp<d0, 1>, exp<d2, 1>>>);
// dimension_divide
static_assert(
std::is_same_v<dimension_divide_t<dimension<e<0, 1>>, dimension<e<1, 1>>>, dimension<e<0, 1>, e<1, -1>>>);
static_assert(std::is_same_v<dimension_divide_t<dimension<e<0, 1>>, dimension<e<0, 1>>>, dimension<>>);
std::is_same_v<dimension_divide_t<dimension<exp<d0, 1>>, dimension<exp<d1, 1>>>, dimension<exp<d0, 1>, exp<d1, -1>>>);
static_assert(std::is_same_v<dimension_divide_t<dimension<exp<d0, 1>>, dimension<exp<d0, 1>>>, dimension<>>);
} // namespace

40
test/unit_test/test_type_list.cpp
View File

@ -82,41 +82,21 @@ namespace {
std::is_same_v<type_list_split_half<type_list<int, long, double, float>>::second_list, type_list<double, float>>);
// type_list_merge_sorted
inline constexpr base_dimension d0{"d0"};
inline constexpr base_dimension d1{"d1"};
static_assert(std::is_same_v<type_list_merge_sorted<type_list<dim_id<0>>, type_list<dim_id<1>>, dim_id_less>,
type_list<dim_id<0>, dim_id<1>>>);
static_assert(std::is_same_v<type_list_merge_sorted<type_list<dim_id<1>>, type_list<dim_id<0>>, dim_id_less>,
type_list<dim_id<0>, dim_id<1>>>);
static_assert(std::is_same_v<type_list_merge_sorted<type_list<dim_id<27>, dim_id<38>>,
type_list<dim_id<3>, dim_id<43>>, dim_id_less>,
type_list<dim_id<3>, dim_id<27>, dim_id<38>, dim_id<43>>>);
static_assert(
std::is_same_v<type_list_merge_sorted<type_list<dim_id<9>, dim_id<82>>, type_list<dim_id<10>>, dim_id_less>,
type_list<dim_id<9>, dim_id<10>, dim_id<82>>>);
static_assert(std::is_same_v<type_list_merge_sorted<type_list<exp<d0, 1>>, type_list<exp<d1, 1>>, exp_less>,
type_list<exp<d0, 1>, exp<d1, 1>>>);
static_assert(std::is_same_v<type_list_merge_sorted<type_list<exp<d1, 1>>, type_list<exp<d0, 1>>, exp_less>,
type_list<exp<d0, 1>, exp<d1, 1>>>);
// type_list_sort
template<TypeList List>
using dim_sort_t = type_list_sort<List, dim_id_less>;
using exp_sort_t = type_list_sort<List, exp_less>;
static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<0>>>, type_list<dim_id<0>>>);
static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<0>, dim_id<1>>>, type_list<dim_id<0>, dim_id<1>>>);
static_assert(std::is_same_v<dim_sort_t<type_list<dim_id<1>, dim_id<0>>>, type_list<dim_id<0>, dim_id<1>>>);
static_assert(std::is_same_v<
dim_sort_t<type_list<dim_id<38>, dim_id<27>, dim_id<43>, dim_id<3>, dim_id<9>, dim_id<82>, dim_id<10>>>,
type_list<dim_id<3>, dim_id<9>, dim_id<10>, dim_id<27>, dim_id<38>, dim_id<43>, dim_id<82>>>);
// exp_dim_id_less
template<int Id, int Value>
using e = exp<dim_id<Id>, Value>;
template<TypeList List>
using exp_sort_t = type_list_sort<List, exp_dim_id_less>;
static_assert(std::is_same_v<exp_sort_t<dimension<e<0, 1>>>, dimension<e<0, 1>>>);
static_assert(std::is_same_v<exp_sort_t<dimension<e<0, 1>, e<1, -1>>>, dimension<e<0, 1>, e<1, -1>>>);
static_assert(std::is_same_v<exp_sort_t<dimension<e<1, 1>, e<0, -1>>>, dimension<e<0, -1>, e<1, 1>>>);
static_assert(std::is_same_v<exp_sort_t<dimension<exp<d0, 1>>>, dimension<exp<d0, 1>>>);
static_assert(std::is_same_v<exp_sort_t<dimension<exp<d0, 1>, exp<d1, -1>>>, dimension<exp<d0, 1>, exp<d1, -1>>>);
static_assert(std::is_same_v<exp_sort_t<dimension<exp<d1, 1>, exp<d0, -1>>>, dimension<exp<d0, -1>, exp<d1, 1>>>);
} // namespace