mirror of
https://github.com/mpusz/mp-units.git
synced 2025-07-30 02:17:16 +02:00
Units and dimensions redesigned
This commit is contained in:
Mateusz Pusz
@ -42,4 +42,4 @@ add_subdirectory(src)
|
||||
add_subdirectory(test)
|
||||
|
||||
# add usage example
|
||||
add_subdirectory(example)
|
||||
#add_subdirectory(example)
|
||||
|
||||
@ -24,7 +24,7 @@ cmake_minimum_required(VERSION 3.8)
|
||||
#cmake_policy(SET CMP0076 NEW)
|
||||
|
||||
project(units
|
||||
VERSION 0.4.0
|
||||
VERSION 0.5.0
|
||||
LANGUAGES CXX
|
||||
)
|
||||
|
||||
|
||||
75
src/include/units/base_dimension.h
Normal file
75
src/include/units/base_dimension.h
Normal file
@ -0,0 +1,75 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <units/bits/fixed_string.h>
|
||||
#include <units/bits/unit_concept.h>
|
||||
#include <units/unit.h>
|
||||
#include <type_traits>
|
||||
|
||||
namespace units {
|
||||
|
||||
/**
|
||||
* @brief A dimension of a base quantity
|
||||
*
|
||||
* Measurement unit that is adopted by convention for a base quantity (a quantity that can not be expressed in terms of
|
||||
* the other quantities within that subset) in a specific system of units.
|
||||
*
|
||||
* Pair of Name and Unit template parameter forms an unique identifier of the base dimension. The same identifiers can
|
||||
* be multiplied and divided which will result with an adjustment of its factor in an Exponent (in case of zero the
|
||||
* dimension will be simplified and removed from further analysis of current expresion). In case the Name is the same
|
||||
* but the Unit differs (i.e. mixing SI and CGS length), there is no automatic simplification but is possible to force
|
||||
* it with a quantity_cast.
|
||||
*
|
||||
* @tparam Name an unique identifier of the base dimension used to provide dimensional analysis support
|
||||
* @tparam U a base unit to be used for this base dimension
|
||||
*/
|
||||
template<basic_fixed_string Name, Unit U>
|
||||
struct base_dimension {
|
||||
using base_type = base_dimension;
|
||||
static constexpr auto name = Name;
|
||||
using coherent_unit = U;
|
||||
};
|
||||
|
||||
// BaseDimension
|
||||
namespace detail {
|
||||
|
||||
template<typename T>
|
||||
inline constexpr bool is_base_dimension = false;
|
||||
|
||||
template<basic_fixed_string Name, typename... Params>
|
||||
inline constexpr bool is_base_dimension<base_dimension<Name, Params...>> = true;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<typename T>
|
||||
concept BaseDimension = detail::is_base_dimension<typename T::base_type>;
|
||||
|
||||
// base_dimension_less
|
||||
// TODO Remove the below when https://bugs.llvm.org/show_bug.cgi?id=32208 is fixed
|
||||
// clang-format off
|
||||
template<BaseDimension D1, BaseDimension D2>
|
||||
struct base_dimension_less : std::bool_constant<D1::name < D2::name> {};
|
||||
// clang-format on
|
||||
|
||||
} // namespace units
|
||||
@ -26,23 +26,53 @@
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace detail {
|
||||
// conditional
|
||||
namespace detail {
|
||||
|
||||
template<bool>
|
||||
struct conditional_impl {
|
||||
template<typename T, typename F>
|
||||
using type = F;
|
||||
};
|
||||
template<bool>
|
||||
struct conditional_impl {
|
||||
template<typename T, typename F>
|
||||
using type = F;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct conditional_impl<true> {
|
||||
template<typename T, typename F>
|
||||
using type = T;
|
||||
};
|
||||
template<>
|
||||
struct conditional_impl<true> {
|
||||
template<typename T, typename F>
|
||||
using type = T;
|
||||
};
|
||||
|
||||
}
|
||||
} // namespace detail
|
||||
|
||||
template<bool B, typename T, typename F>
|
||||
using conditional = detail::conditional_impl<B>::template type<T, F>;
|
||||
template<bool B, typename T, typename F>
|
||||
using conditional = detail::conditional_impl<B>::template type<T, F>;
|
||||
|
||||
}
|
||||
// is_instantiation
|
||||
namespace detail {
|
||||
|
||||
template<typename T, template<typename...> typename Type>
|
||||
inline constexpr bool is_instantiation_impl = false;
|
||||
|
||||
template<typename... Params, template<typename...> typename Type>
|
||||
inline constexpr bool is_instantiation_impl<Type<Params...>, Type> = true;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<typename T, template<typename...> typename Type>
|
||||
inline constexpr bool is_instantiation = detail::is_instantiation_impl<T, Type>;
|
||||
|
||||
// is_derived_from_instantiation
|
||||
namespace detail {
|
||||
|
||||
template<template<typename...> typename Type>
|
||||
struct is_derived_from_instantiation_impl {
|
||||
template<typename... Params>
|
||||
static constexpr std::true_type check_base(const Type<Params...>&);
|
||||
static constexpr std::true_type check_base(...);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<typename T, template<typename...> typename Type>
|
||||
inline constexpr bool is_derived_from_instantiation = decltype(detail::is_derived_from_instantiation_impl<Type>::check_base(std::declval<T>()))::value;
|
||||
|
||||
} // namespace units
|
||||
|
||||
41
src/include/units/bits/unit_concept.h
Normal file
41
src/include/units/bits/unit_concept.h
Normal file
@ -0,0 +1,41 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <units/bits/type_traits.h>
|
||||
#include <units/ratio.h>
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<typename U, Ratio R>
|
||||
struct reference_unit;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// Unit
|
||||
template<typename T>
|
||||
concept Unit = is_derived_from_instantiation<T, detail::reference_unit>;
|
||||
|
||||
} // namespace units
|
||||
403
src/include/units/derived_dimension.h
Normal file
403
src/include/units/derived_dimension.h
Normal file
@ -0,0 +1,403 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <units/base_dimension.h>
|
||||
#include <units/bits/downcasting.h>
|
||||
#include <units/bits/fixed_string.h>
|
||||
#include <units/bits/type_list.h>
|
||||
#include <units/ratio.h>
|
||||
#include <ratio>
|
||||
|
||||
namespace units {
|
||||
|
||||
// Exponent
|
||||
namespace detail {
|
||||
|
||||
template<typename T>
|
||||
inline constexpr bool is_exp = false;
|
||||
|
||||
// partial specialization for an exp type provided below
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<typename T>
|
||||
concept Exponent = detail::is_exp<T>;
|
||||
|
||||
/**
|
||||
* @brief A derived dimension
|
||||
*
|
||||
* There are 2 partial specializations of this primary class template. One of them is used by the library engine
|
||||
* and another one is the interface for the user to define a derived dimension.
|
||||
*/
|
||||
template<typename...>
|
||||
struct derived_dimension;
|
||||
|
||||
/**
|
||||
* @brief Dimensionless quantity
|
||||
*/
|
||||
template<>
|
||||
struct derived_dimension<> : downcast_base<derived_dimension<>> {};
|
||||
|
||||
/**
|
||||
* @brief A dimension of a derived quantity
|
||||
*
|
||||
* Expression of the dependence of a quantity on the base quantities (and their base dimensions) of a system of
|
||||
* quantities as a product of powers of factors corresponding to the base quantities, omitting any numerical factors.
|
||||
* A power of a factor is the factor raised to an exponent.
|
||||
*
|
||||
* A derived dimension can be formed from multiple exponents (i.e. velocity is represented as "exp<L, 1>, exp<T, -1>").
|
||||
* It is also possible to form a derived dimension with only one exponent (i.e. frequency is represented as just
|
||||
* "exp<T, -1>").
|
||||
*
|
||||
* @note This partial class template specialization is used by the library engine and should not be directly instantiated
|
||||
* by the user (see the other partial specialization).
|
||||
*
|
||||
* @tparam E a first exponent of a derived dimension
|
||||
* @tparam ERest zero or more following exponents of a derived dimension
|
||||
*/
|
||||
template<Exponent E, Exponent... ERest>
|
||||
struct derived_dimension<E, ERest...> : downcast_base<derived_dimension<E, ERest...>> {};
|
||||
|
||||
// DerivedDimension
|
||||
template<typename T>
|
||||
concept DerivedDimension = std::is_empty_v<T> && is_instantiation<downcast_base_t<T>, derived_dimension>;
|
||||
|
||||
// Dimension
|
||||
template<typename T>
|
||||
concept Dimension = BaseDimension<T> || DerivedDimension<T>;
|
||||
|
||||
/**
|
||||
* @brief A power of factor corresponding to the dimension of a quantity
|
||||
*
|
||||
* @tparam Dim component dimension of a derived quantity
|
||||
* @tparam Num numinator of the factor
|
||||
* @tparam Den denominator of the factor
|
||||
*/
|
||||
template<Dimension Dim, int Num, int Den = 1>
|
||||
struct exp {
|
||||
using dimension = Dim;
|
||||
static constexpr int num = Num;
|
||||
static constexpr int den = Den;
|
||||
};
|
||||
|
||||
// is_exp
|
||||
namespace detail {
|
||||
|
||||
template<typename Dim, int Num, int Den>
|
||||
inline constexpr bool is_exp<exp<Dim, Num, Den>> = true;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// exp_less
|
||||
template<Exponent E1, Exponent E2>
|
||||
struct exp_less : base_dimension_less<typename E1::dimension, typename E2::dimension> {};
|
||||
|
||||
// exp_invert
|
||||
namespace detail {
|
||||
|
||||
template<typename Dim, int Num, int Den>
|
||||
constexpr exp<Dim, -Num, Den> exp_invert_impl(exp<Dim, Num, Den>);
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<Exponent E>
|
||||
using exp_invert = decltype(detail::exp_invert_impl(E()));
|
||||
|
||||
// exp_multiply
|
||||
namespace detail {
|
||||
|
||||
template<Exponent E, int Num, int Den>
|
||||
struct exp_multiply_impl {
|
||||
using r1 = ratio<E::num, E::den>;
|
||||
using r2 = ratio<Num, Den>;
|
||||
using r = ratio_multiply<r1, r2>;
|
||||
using type = exp<typename E::dimension, r::num, r::den>;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<Exponent E, int Num, int Den>
|
||||
using exp_multiply = detail::exp_multiply_impl<E, Num, Den>::type;
|
||||
|
||||
// make_dimension
|
||||
namespace detail {
|
||||
|
||||
/**
|
||||
* @brief Consolidates contiguous ranges of exponents of the same dimension
|
||||
*
|
||||
* If there is more than one exponent with the same dimension they are aggregated into one exponent by adding
|
||||
* their exponents. If this accumulation will result with 0, such a dimension is removed from the list.
|
||||
*
|
||||
* @tparam D derived dimension to consolidate
|
||||
*/
|
||||
template<DerivedDimension D>
|
||||
struct dim_consolidate;
|
||||
|
||||
template<>
|
||||
struct dim_consolidate<derived_dimension<>> {
|
||||
using type = derived_dimension<>;
|
||||
};
|
||||
|
||||
template<typename E>
|
||||
struct dim_consolidate<derived_dimension<E>> {
|
||||
using type = derived_dimension<E>;
|
||||
};
|
||||
|
||||
template<typename E1, typename... ERest>
|
||||
struct dim_consolidate<derived_dimension<E1, ERest...>> {
|
||||
using type = type_list_push_front<typename dim_consolidate<derived_dimension<ERest...>>::type, E1>;
|
||||
};
|
||||
|
||||
template<BaseDimension Dim, int Num1, int Den1, int Num2, int Den2, typename... ERest>
|
||||
struct dim_consolidate<derived_dimension<exp<Dim, Num1, Den1>, exp<Dim, Num2, Den2>, ERest...>> {
|
||||
// TODO: provide custom implementation for ratio_add
|
||||
using r1 = std::ratio<Num1, Den1>;
|
||||
using r2 = std::ratio<Num2, Den2>;
|
||||
using r = std::ratio_add<r1, r2>;
|
||||
using type = conditional<r::num == 0, typename dim_consolidate<derived_dimension<ERest...>>::type,
|
||||
typename dim_consolidate<derived_dimension<exp<Dim, r::num, r::den>, ERest...>>::type>;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Extracts the list of potentially derived dimensions to a list containing only base dimensions
|
||||
*
|
||||
* @tparam Es Exponents of potentially derived dimensions
|
||||
*/
|
||||
template<Exponent... Es>
|
||||
struct extract;
|
||||
|
||||
template<>
|
||||
struct extract<> {
|
||||
using type = derived_dimension<>;
|
||||
};
|
||||
|
||||
template<BaseDimension Dim, int Num, int Den, Exponent... ERest>
|
||||
struct extract<exp<Dim, Num, Den>, ERest...> {
|
||||
using type = type_list_push_front<typename extract<ERest...>::type, exp<Dim, Num, Den>>;
|
||||
};
|
||||
|
||||
template<DerivedDimension Dim, int Num, int Den, Exponent... ERest>
|
||||
struct extract<exp<Dim, Num, Den>, ERest...> {
|
||||
using type = extract<exp<downcast_base_t<Dim>, Num, Den>, ERest...>::type;
|
||||
};
|
||||
|
||||
template<Exponent... Es, int Num, int Den, Exponent... ERest>
|
||||
struct extract<exp<derived_dimension<Es...>, Num, Den>, ERest...> {
|
||||
using type = type_list_push_front<typename extract<ERest...>::type, exp_multiply<Es, Num, Den>...>;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Converts user provided derived dimension specification into a valid units::derived_dimension definition
|
||||
*
|
||||
* User provided definition of a derived dimension may contain the same base dimension repeated more than once on the
|
||||
* list possibly hidden in other derived units provided by the user. The process here should:
|
||||
* 1. Extract derived dimensions into exponents of base dimensions.
|
||||
* 2. Sort the exponents so the same dimensions are placed next to each other.
|
||||
* 3. Consolidate contiguous range of exponents of the same base dimensions to a one (or possibly zero) exponent for
|
||||
* this base dimension.
|
||||
*/
|
||||
template<Exponent... Es>
|
||||
using make_dimension = dim_consolidate<type_list_sort<typename extract<Es...>::type, exp_less>>::type;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
/**
|
||||
* @brief The list of exponents of dimensions (both base and derived) provided by the user
|
||||
*
|
||||
* This is the primary interface to create derived dimensions. Exponents list can contain powers of factors of both
|
||||
* base and derived dimensions. This is called a "recipe" of the dimension and among others is used to print
|
||||
* unnamed coherent units of this dimension.
|
||||
*
|
||||
* The implementation is responsible for unpacking all of the dimensions into a list containing only base dimensions
|
||||
* and their factors and putting them to the other (private) units::derived_dimension class template partial
|
||||
* specialization.
|
||||
*
|
||||
* @note User should always use only this partial specialization to create derived dimensions.
|
||||
*
|
||||
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
|
||||
* @tparam E The list of exponents of ingredient dimensions
|
||||
* @tparam ERest The list of exponents of ingredient dimensions
|
||||
*/
|
||||
template<typename Child, Unit U, Exponent E, Exponent... ERest>
|
||||
requires (!Exponent<Child>)
|
||||
struct derived_dimension<Child, U, E, ERest...> : downcast_child<Child, typename detail::make_dimension<E, ERest...>> {
|
||||
using recipe = derived_dimension<E, ERest...>;
|
||||
using coherent_unit = U;
|
||||
};
|
||||
|
||||
// same_dim
|
||||
template<Dimension D1, Dimension D2>
|
||||
inline constexpr bool same_dim;
|
||||
|
||||
template<BaseDimension D1, BaseDimension D2>
|
||||
inline constexpr bool same_dim<D1, D2> = std::is_same_v<D1, D2>;
|
||||
|
||||
template<DerivedDimension D1, DerivedDimension D2>
|
||||
inline constexpr bool same_dim<D1, D2> = std::is_same_v<typename D1::base_type, typename D2::base_type>;
|
||||
|
||||
// dim_invert
|
||||
namespace detail {
|
||||
|
||||
template<Dimension D>
|
||||
struct dim_invert_impl;
|
||||
|
||||
template<BaseDimension D>
|
||||
struct dim_invert_impl<D> {
|
||||
using type = downcast<derived_dimension<exp<D, -1>>>;
|
||||
};
|
||||
|
||||
template<BaseDimension D>
|
||||
struct dim_invert_impl<derived_dimension<exp<D, -1>>> {
|
||||
using type = D;
|
||||
};
|
||||
|
||||
template<typename... Es>
|
||||
struct dim_invert_impl<derived_dimension<Es...>> {
|
||||
using type = downcast<derived_dimension<exp_invert<Es>...>>;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<Dimension D>
|
||||
using dim_invert = detail::dim_invert_impl<downcast_base_t<D>>::type;
|
||||
|
||||
// dimension_multiply
|
||||
namespace detail {
|
||||
|
||||
template<Dimension D>
|
||||
struct dim_unpack {
|
||||
using type = D;
|
||||
};
|
||||
|
||||
template<BaseDimension D>
|
||||
struct dim_unpack<derived_dimension<exp<D, 1>>> {
|
||||
using type = D;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Merges 2 sorted derived dimensions into one units::derived_dimension
|
||||
*
|
||||
* A result of a dimensional calculation may result with many exponents of the same base dimension orginated
|
||||
* from different parts of the equation. As the exponents lists of both operands it is enough to merge them
|
||||
* into one list and consolidate duplicates. Also it is possible that final exponents list will contain only
|
||||
* one element being a base dimension with exponent 1. In such a case the final dimension should be the base
|
||||
* dimension itself.
|
||||
*/
|
||||
template<Dimension D1, Dimension D2>
|
||||
using merge_dimension = dim_unpack<typename dim_consolidate<type_list_merge_sorted<D1, D2, exp_less>>::type>::type;
|
||||
|
||||
template<Dimension D1, Dimension D2>
|
||||
struct dimension_multiply_impl;
|
||||
|
||||
template<BaseDimension D1, BaseDimension D2>
|
||||
struct dimension_multiply_impl<D1, D2> {
|
||||
using type = downcast<merge_dimension<derived_dimension<exp<D1, 1>>, derived_dimension<exp<D2, 1>>>>;
|
||||
};
|
||||
|
||||
template<BaseDimension D1, DerivedDimension D2>
|
||||
struct dimension_multiply_impl<D1, D2> {
|
||||
using type = downcast<merge_dimension<derived_dimension<exp<D1, 1>>, typename D2::base_type>>;
|
||||
};
|
||||
|
||||
template<DerivedDimension D1, BaseDimension D2>
|
||||
struct dimension_multiply_impl<D1, D2> {
|
||||
using type = dimension_multiply_impl<D2, D1>::type;
|
||||
};
|
||||
|
||||
template<DerivedDimension D1, DerivedDimension D2>
|
||||
struct dimension_multiply_impl<D1, D2> {
|
||||
using type = downcast<merge_dimension<typename D1::base_type, typename D2::base_type>>;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<Dimension D1, Dimension D2>
|
||||
using dimension_multiply = detail::dimension_multiply_impl<D1, D2>::type;
|
||||
|
||||
template<Dimension D1, Dimension D2>
|
||||
using dimension_divide = detail::dimension_multiply_impl<D1, dim_invert<D2>>::type;
|
||||
|
||||
// dimension_sqrt
|
||||
namespace detail {
|
||||
|
||||
template<Dimension D>
|
||||
struct dimension_sqrt_impl;
|
||||
|
||||
template<BaseDimension D>
|
||||
struct dimension_sqrt_impl<D> {
|
||||
using type = derived_dimension<exp<D, 1, 2>>;
|
||||
};
|
||||
|
||||
template<BaseDimension D>
|
||||
struct dimension_sqrt_impl<derived_dimension<exp<D, 2>>> {
|
||||
using type = D;
|
||||
};
|
||||
|
||||
template<DerivedDimension D>
|
||||
struct dimension_sqrt_impl<D> {
|
||||
using type = dimension_sqrt_impl<typename D::base_type>;
|
||||
};
|
||||
|
||||
template<typename... Es>
|
||||
struct dimension_sqrt_impl<derived_dimension<Es...>> {
|
||||
using type = downcast<derived_dimension<exp_multiply<Es, 1, 2>...>>;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<Dimension D>
|
||||
using dimension_sqrt = detail::dimension_sqrt_impl<typename D::base_type>::type;
|
||||
|
||||
// dimension_pow
|
||||
namespace detail {
|
||||
|
||||
template<Dimension D, std::size_t N>
|
||||
struct dimension_pow_impl;
|
||||
|
||||
template<BaseDimension D, std::size_t N>
|
||||
struct dimension_pow_impl<D, N> {
|
||||
using type = derived_dimension<exp<D, N>>;
|
||||
};
|
||||
|
||||
template<BaseDimension D, std::size_t N>
|
||||
struct dimension_pow_impl<exp<D, 1, N>, N> {
|
||||
using type = D;
|
||||
};
|
||||
|
||||
template<DerivedDimension D, std::size_t N>
|
||||
struct dimension_pow_impl<D, N> {
|
||||
using type = dimension_pow_impl<typename D::base_type, N>;
|
||||
};
|
||||
|
||||
template<typename... Es, std::size_t N>
|
||||
struct dimension_pow_impl<derived_dimension<Es...>, N> {
|
||||
using type = downcast<derived_dimension<exp_multiply<Es, N, 1>...>>;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<Dimension D, std::size_t N>
|
||||
using dimension_pow = detail::dimension_pow_impl<D, N>::type;
|
||||
|
||||
} // namespace units
|
||||
@ -1,292 +0,0 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <units/bits/type_list.h>
|
||||
#include <units/bits/downcasting.h>
|
||||
#include <units/bits/fixed_string.h>
|
||||
#include <units/ratio.h>
|
||||
#include <ratio>
|
||||
|
||||
namespace units {
|
||||
|
||||
template<basic_fixed_string Name, basic_fixed_string Symbol>
|
||||
struct base_dimension {
|
||||
static constexpr auto name = Name;
|
||||
static constexpr auto symbol = Symbol;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
concept BaseDimension = std::is_empty_v<T> &&
|
||||
requires {
|
||||
T::name;
|
||||
T::symbol;
|
||||
};// && // TODO file a bug for this gcc issue
|
||||
// std::derived_from<T, base_dimension<T::name, T::symbol>>;
|
||||
|
||||
// base_dimension_less
|
||||
|
||||
template<BaseDimension D1, BaseDimension D2>
|
||||
struct base_dimension_less : std::bool_constant<D1::name < D2::name> {
|
||||
};
|
||||
|
||||
// is_exp
|
||||
namespace detail {
|
||||
|
||||
template<typename T>
|
||||
inline constexpr bool is_exp = false;
|
||||
|
||||
// partial specialization for an exp type provided below
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<typename T>
|
||||
concept Exponent = detail::is_exp<T>;
|
||||
|
||||
template<Exponent... Es>
|
||||
struct dimension;
|
||||
|
||||
// is_dimension
|
||||
namespace detail {
|
||||
|
||||
template<typename T>
|
||||
inline constexpr bool is_dimension = false;
|
||||
|
||||
template<typename... Es>
|
||||
inline constexpr bool is_dimension<dimension<Es...>> = true;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<typename T>
|
||||
concept Dimension =
|
||||
std::is_empty_v<T> &&
|
||||
detail::is_dimension<downcast_base_t<T>>;
|
||||
|
||||
// exp
|
||||
template<typename BaseOrDim, int Num, int Den = 1>
|
||||
requires BaseDimension<BaseOrDim> || Dimension<BaseOrDim>
|
||||
struct exp {
|
||||
using dimension = BaseOrDim;
|
||||
static constexpr int num = Num;
|
||||
static constexpr int den = Den;
|
||||
};
|
||||
|
||||
// is_exp
|
||||
namespace detail {
|
||||
|
||||
template<typename Dim, int Num, int Den>
|
||||
inline constexpr bool is_exp<exp<Dim, Num, Den>> = true;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// exp_less
|
||||
template<Exponent E1, Exponent E2>
|
||||
struct exp_less : base_dimension_less<typename E1::dimension, typename E2::dimension> {
|
||||
};
|
||||
|
||||
// exp_invert
|
||||
namespace detail {
|
||||
|
||||
template<Exponent E>
|
||||
struct exp_invert_impl;
|
||||
|
||||
template<typename Dim, int Num, int Den>
|
||||
struct exp_invert_impl<exp<Dim, Num, Den>> {
|
||||
using type = exp<Dim, -Num, Den>;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template<Exponent E>
|
||||
using exp_invert = detail::exp_invert_impl<E>::type;
|
||||
|
||||
// exp_multiply
|
||||
namespace detail {
|
||||
|
||||
template<Exponent E, int Num, int Den>
|
||||
struct exp_multiply_impl {
|
||||
using r1 = ratio<E::num, E::den>;
|
||||
using r2 = ratio<Num, Den>;
|
||||
using r = ratio_multiply<r1, r2>;
|
||||
using type = exp<typename E::dimension, r::num, r::den>;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template<Exponent E, int Num, int Den>
|
||||
using exp_multiply = detail::exp_multiply_impl<E, Num, Den>::type;
|
||||
|
||||
// dimension
|
||||
template<Exponent... Es>
|
||||
struct dimension : downcast_base<dimension<Es...>> {};
|
||||
|
||||
// same_dim
|
||||
template<typename D1, Dimension D2>
|
||||
requires BaseDimension<D1> || Dimension<D1>
|
||||
inline constexpr bool same_dim = std::is_same_v<typename D1::base_type, typename D2::base_type>;
|
||||
|
||||
template<BaseDimension D1, Dimension D2>
|
||||
inline constexpr bool same_dim<D1, D2> = std::is_same_v<dimension<units::exp<D1, 1>>, typename D2::base_type>;
|
||||
|
||||
// dim_invert
|
||||
namespace detail {
|
||||
|
||||
template<Dimension E>
|
||||
struct dim_invert_impl;
|
||||
|
||||
template<typename... Es>
|
||||
struct dim_invert_impl<dimension<Es...>> : std::type_identity<downcast<dimension<exp_invert<Es>...>>> {};
|
||||
|
||||
}
|
||||
|
||||
template<Dimension D>
|
||||
using dim_invert = detail::dim_invert_impl<downcast_base_t<D>>::type;
|
||||
|
||||
// make_dimension
|
||||
namespace detail {
|
||||
|
||||
template<Dimension D>
|
||||
struct dim_consolidate;
|
||||
|
||||
template<>
|
||||
struct dim_consolidate<dimension<>> {
|
||||
using type = dimension<>;
|
||||
};
|
||||
|
||||
template<typename E>
|
||||
struct dim_consolidate<dimension<E>> {
|
||||
using type = dimension<E>;
|
||||
};
|
||||
|
||||
template<typename E1, typename... ERest>
|
||||
struct dim_consolidate<dimension<E1, ERest...>> {
|
||||
using type = type_list_push_front<typename dim_consolidate<dimension<ERest...>>::type, E1>;
|
||||
};
|
||||
|
||||
template<BaseDimension D, int Num1, int Den1, int Num2, int Den2, typename... ERest>
|
||||
struct dim_consolidate<dimension<exp<D, Num1, Den1>, exp<D, Num2, Den2>, ERest...>> {
|
||||
// TODO: provide custom implementation for ratio_add
|
||||
using r1 = std::ratio<Num1, Den1>;
|
||||
using r2 = std::ratio<Num2, Den2>;
|
||||
using r = std::ratio_add<r1, r2>;
|
||||
using type = conditional<r::num == 0, typename dim_consolidate<dimension<ERest...>>::type,
|
||||
typename dim_consolidate<dimension<exp<D, r::num, r::den>, ERest...>>::type>;
|
||||
};
|
||||
|
||||
template<Exponent... Es>
|
||||
struct extract;
|
||||
|
||||
template<>
|
||||
struct extract<> {
|
||||
using type = dimension<>;
|
||||
};
|
||||
|
||||
template<BaseDimension Dim, int Num, int Den, Exponent... ERest>
|
||||
struct extract<exp<Dim, Num, Den>, ERest...> {
|
||||
using type = type_list_push_front<typename extract<ERest...>::type, exp<Dim, Num, Den>>;
|
||||
};
|
||||
|
||||
template<Exponent... Es, int Num, int Den, Exponent... ERest>
|
||||
struct extract<exp<dimension<Es...>, Num, Den>, ERest...> {
|
||||
using type = type_list_push_front<typename extract<ERest...>::type, exp_multiply<Es, Num, Den>...>;
|
||||
};
|
||||
|
||||
template<Dimension Dim, int Num, int Den, Exponent... ERest>
|
||||
struct extract<exp<Dim, Num, Den>, ERest...> {
|
||||
using type = extract<exp<downcast_base_t<Dim>, Num, Den>, ERest...>::type;
|
||||
};
|
||||
|
||||
template<Exponent... Es>
|
||||
using make_dimension = dim_consolidate<type_list_sort<typename extract<Es...>::type, exp_less>>::type;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// derived_dimension
|
||||
template<typename Child, Exponent... Es>
|
||||
struct derived_dimension : downcast_child<Child, typename detail::make_dimension<Es...>> {
|
||||
using recipe = dimension<Es...>;
|
||||
};
|
||||
|
||||
// merge_dimension
|
||||
template<Dimension D1, Dimension D2>
|
||||
using merge_dimension = detail::dim_consolidate<type_list_merge_sorted<D1, D2, exp_less>>::type;
|
||||
|
||||
// dimension_multiply
|
||||
namespace detail {
|
||||
|
||||
template<typename D1, typename D2>
|
||||
struct dimension_multiply_impl;
|
||||
|
||||
template<typename... E1, typename... E2>
|
||||
struct dimension_multiply_impl<dimension<E1...>, dimension<E2...>> : std::type_identity<downcast<merge_dimension<dimension<E1...>, dimension<E2...>>>> {};
|
||||
|
||||
}
|
||||
|
||||
template<Dimension D1, Dimension D2>
|
||||
using dimension_multiply = detail::dimension_multiply_impl<typename D1::base_type, typename D2::base_type>::type;
|
||||
|
||||
// dimension_divide
|
||||
namespace detail {
|
||||
|
||||
template<typename D1, typename D2>
|
||||
struct dimension_divide_impl;
|
||||
|
||||
template<typename... E1, typename... E2>
|
||||
struct dimension_divide_impl<dimension<E1...>, dimension<E2...>>
|
||||
: dimension_multiply_impl<dimension<E1...>, dimension<exp_invert<E2>...>> {
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template<Dimension D1, Dimension D2>
|
||||
using dimension_divide = detail::dimension_divide_impl<typename D1::base_type, typename D2::base_type>::type;
|
||||
|
||||
// dimension_sqrt
|
||||
namespace detail {
|
||||
|
||||
template<typename D>
|
||||
struct dimension_sqrt_impl;
|
||||
|
||||
template<typename... Es>
|
||||
struct dimension_sqrt_impl<dimension<Es...>> : std::type_identity<downcast<dimension<exp_multiply<Es, 1, 2>...>>> {};
|
||||
|
||||
}
|
||||
|
||||
template<Dimension D>
|
||||
using dimension_sqrt = detail::dimension_sqrt_impl<typename D::base_type>::type;
|
||||
|
||||
// dimension_pow
|
||||
namespace detail {
|
||||
|
||||
template<typename D, std::size_t N>
|
||||
struct dimension_pow_impl;
|
||||
|
||||
template<typename... Es, std::size_t N>
|
||||
struct dimension_pow_impl<dimension<Es...>, N> : std::type_identity<downcast<dimension<exp_multiply<Es, N, 1>...>>> {};
|
||||
|
||||
}
|
||||
|
||||
template<Dimension D, std::size_t N>
|
||||
using dimension_pow = detail::dimension_pow_impl<typename D::base_type, N>::type;
|
||||
|
||||
} // namespace units
|
||||
37
src/include/units/dimensions/base_dimensions.h
Normal file
37
src/include/units/dimensions/base_dimensions.h
Normal file
@ -0,0 +1,37 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <units/dimension.h>
|
||||
|
||||
namespace units {
|
||||
|
||||
struct base_dim_length : base_dimension<"length", "m"> {};
|
||||
struct base_dim_mass : base_dimension<"mass", "kg"> {};
|
||||
struct base_dim_time : base_dimension<"time", "s"> {};
|
||||
struct base_dim_current : base_dimension<"current", "A"> {};
|
||||
struct base_dim_temperature : base_dimension<"temperature", "K"> {};
|
||||
struct base_dim_substance : base_dimension<"substance", "mol"> {};
|
||||
struct base_dim_luminous_intensity : base_dimension<"luminous intensity", "cd"> {};
|
||||
|
||||
} // namespace units
|
||||
@ -1,52 +0,0 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <units/unit.h>
|
||||
#include <units/format.h>
|
||||
|
||||
namespace units {
|
||||
|
||||
// prefix tags
|
||||
struct si_prefix : prefix_type {};
|
||||
|
||||
// SI prefixes
|
||||
|
||||
struct atto : prefix<atto, si_prefix, ratio<1, std::atto::den>, "a"> {};
|
||||
struct femto : prefix<femto, si_prefix, ratio<1, std::femto::den>, "f"> {};
|
||||
struct pico : prefix<pico, si_prefix, ratio<1, std::pico::den>, "p"> {};
|
||||
struct nano : prefix<nano, si_prefix, ratio<1, std::nano::den>, "n"> {};
|
||||
struct micro : prefix<micro, si_prefix, ratio<1, std::micro::den>, "\u00b5"> {};
|
||||
struct milli : prefix<milli, si_prefix, ratio<1, std::milli::den>, "m"> {};
|
||||
struct centi : prefix<centi, si_prefix, ratio<1, std::centi::den>, "c"> {};
|
||||
struct deci : prefix<deci, si_prefix, ratio<1, std::deci::den>, "d"> {};
|
||||
struct deca : prefix<deca, si_prefix, ratio<std::deca::num>, "da"> {};
|
||||
struct hecto : prefix<hecto, si_prefix, ratio<std::hecto::num>, "h"> {};
|
||||
struct kilo : prefix<kilo, si_prefix, ratio<std::kilo::num>, "k"> {};
|
||||
struct mega : prefix<mega, si_prefix, ratio<std::mega::num>, "M"> {};
|
||||
struct giga : prefix<giga, si_prefix, ratio<std::giga::num>, "G"> {};
|
||||
struct tera : prefix<tera, si_prefix, ratio<std::tera::num>, "T"> {};
|
||||
struct peta : prefix<peta, si_prefix, ratio<std::peta::num>, "P"> {};
|
||||
struct exa : prefix<exa, si_prefix, ratio<std::exa::num>, "E"> {};
|
||||
|
||||
}
|
||||
51
src/include/units/physical/si/prefixes.h
Normal file
51
src/include/units/physical/si/prefixes.h
Normal file
@ -0,0 +1,51 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <units/prefix.h>
|
||||
#include <ratio>
|
||||
|
||||
namespace units::si {
|
||||
|
||||
struct prefix : prefix_type {};
|
||||
|
||||
// TODO Remove dependency on std::ratio
|
||||
|
||||
struct atto : units::prefix<atto, prefix, "a", ratio<1, std::atto::den>> {};
|
||||
struct femto : units::prefix<femto, prefix, "f", ratio<1, std::femto::den>> {};
|
||||
struct pico : units::prefix<pico, prefix, "p", ratio<1, std::pico::den>> {};
|
||||
struct nano : units::prefix<nano, prefix, "n", ratio<1, std::nano::den>> {};
|
||||
struct micro : units::prefix<micro, prefix, "\u00b5", ratio<1, std::micro::den>> {};
|
||||
struct milli : units::prefix<milli, prefix, "m", ratio<1, std::milli::den>> {};
|
||||
struct centi : units::prefix<centi, prefix, "c", ratio<1, std::centi::den>> {};
|
||||
struct deci : units::prefix<deci, prefix, "d", ratio<1, std::deci::den>> {};
|
||||
struct deca : units::prefix<deca, prefix, "da", ratio<std::deca::num>> {};
|
||||
struct hecto : units::prefix<hecto, prefix, "h", ratio<std::hecto::num>> {};
|
||||
struct kilo : units::prefix<kilo, prefix, "k", ratio<std::kilo::num>> {};
|
||||
struct mega : units::prefix<mega, prefix, "M", ratio<std::mega::num>> {};
|
||||
struct giga : units::prefix<giga, prefix, "G", ratio<std::giga::num>> {};
|
||||
struct tera : units::prefix<tera, prefix, "T", ratio<std::tera::num>> {};
|
||||
struct peta : units::prefix<peta, prefix, "P", ratio<std::peta::num>> {};
|
||||
struct exa : units::prefix<exa, prefix, "E", ratio<std::exa::num>> {};
|
||||
|
||||
} // namespace units::si
|
||||
@ -28,43 +28,69 @@
|
||||
|
||||
namespace units {
|
||||
|
||||
struct prefix_type {};
|
||||
/**
|
||||
* @brief The base for all prefix types
|
||||
*
|
||||
* Every prefix type should inherit from this type to satisfy PrefixType concept.
|
||||
*/
|
||||
struct prefix_type {};
|
||||
|
||||
template<typename T>
|
||||
concept PrefixType = std::derived_from<T, prefix_type>;
|
||||
template<typename T>
|
||||
concept PrefixType = std::derived_from<T, prefix_type>;
|
||||
|
||||
namespace detail {
|
||||
/**
|
||||
* @brief No prefix possible for the unit
|
||||
*
|
||||
* This is a special prefix type tag specifying that the unit can not be scaled with any kind
|
||||
* of the prefix.
|
||||
*/
|
||||
struct no_prefix : prefix_type {};
|
||||
|
||||
template<PrefixType PT, Ratio R>
|
||||
struct prefix_base : downcast_base<prefix_base<PT, R>> {
|
||||
using prefix_type = PT;
|
||||
using ratio = R;
|
||||
};
|
||||
namespace detail {
|
||||
|
||||
}
|
||||
template<PrefixType PT, Ratio R>
|
||||
struct prefix_base : downcast_base<prefix_base<PT, R>> {
|
||||
using prefix_type = PT;
|
||||
using ratio = R;
|
||||
};
|
||||
|
||||
template<typename Child, PrefixType PT, Ratio R, basic_fixed_string Symbol>
|
||||
struct prefix : downcast_child<Child, detail::prefix_base<PT, R>> {
|
||||
static constexpr auto symbol = Symbol;
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
/**
|
||||
* @brief A prefix used to scale units
|
||||
*
|
||||
* Data from a prefix class is used in two cases:
|
||||
* - when defining a prefixed_unit its ratio is used to scale the reference unit and its
|
||||
* symbol is used to prepend to the symbol of referenced unit
|
||||
* - when printing the symbol of a scaled unit that was not predefined by the user but its
|
||||
* factor matches ratio of a prefix from the specified prefix family, its symbol will be
|
||||
* prepended to the symbol of the unit
|
||||
*
|
||||
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
|
||||
* @tparam PT a type of prefix family
|
||||
* @tparam Symbol a text representation of the prefix
|
||||
* @tparam R factor to be used to scale a unit
|
||||
*/
|
||||
template<typename Child, PrefixType PT, basic_fixed_string Symbol, Ratio R>
|
||||
requires(!std::same_as<PT, no_prefix>)
|
||||
struct prefix : downcast_child<Child, detail::prefix_base<PT, ratio<R::num, R::den>>> {
|
||||
static constexpr auto symbol = Symbol;
|
||||
};
|
||||
|
||||
// TODO gcc:92150
|
||||
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=92150
|
||||
// namespace detail {
|
||||
// TODO gcc:92150
|
||||
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=92150
|
||||
// namespace detail {
|
||||
|
||||
// template<typename T>
|
||||
// inline constexpr bool is_prefix = false;
|
||||
// template<typename T>
|
||||
// inline constexpr bool is_prefix = false;
|
||||
|
||||
// template<typename PrefixType, Ratio R, basic_fixed_string Symbol>
|
||||
// inline constexpr bool is_prefix<prefix<PrefixType, R, Symbol>> = true;
|
||||
// template<typename PrefixType, Ratio R, basic_fixed_string Symbol>
|
||||
// inline constexpr bool is_prefix<prefix<PrefixType, R, Symbol>> = true;
|
||||
|
||||
// } // namespace detail
|
||||
// } // namespace detail
|
||||
|
||||
template<typename T>
|
||||
template<typename T>
|
||||
// concept Prefix = detail::is_prefix<T>;
|
||||
concept Prefix = true;
|
||||
|
||||
struct no_prefix : prefix_type {};
|
||||
concept Prefix = true;
|
||||
|
||||
} // namespace units
|
||||
|
||||
@ -22,353 +22,185 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <units/dimension.h>
|
||||
#include <units/bits/downcasting.h>
|
||||
#include <units/bits/fixed_string.h>
|
||||
#include <units/bits/type_traits.h>
|
||||
#include <units/bits/unit_concept.h>
|
||||
#include <units/derived_dimension.h>
|
||||
#include <units/prefix.h>
|
||||
#include <units/ratio.h>
|
||||
#include <ratio>
|
||||
|
||||
namespace units {
|
||||
|
||||
template<Dimension D, Ratio R>
|
||||
requires (R::num * R::den > 0)
|
||||
struct unit : downcast_base<unit<D, R>> {
|
||||
using dimension = D;
|
||||
using ratio = R;
|
||||
};
|
||||
namespace detail {
|
||||
|
||||
// is_unit
|
||||
template<typename U, Ratio R>
|
||||
struct reference_unit : downcast_base<reference_unit<U, R>> {
|
||||
using reference = U;
|
||||
using ratio = R;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
} // namespace detail
|
||||
|
||||
template<typename T>
|
||||
inline constexpr bool is_unit = false;
|
||||
namespace detail {
|
||||
|
||||
template<typename D, typename R>
|
||||
inline constexpr bool is_unit<unit<D, R>> = true;
|
||||
// same_reference_units
|
||||
template<DerivedDimension D, Unit... Us>
|
||||
inline constexpr bool same_reference_units = false;
|
||||
|
||||
}
|
||||
template<typename... Es, Unit... Us>
|
||||
inline constexpr bool same_reference_units<derived_dimension<Es...>, Us...> =
|
||||
(std::same_as<typename Es::dimension::coherent_unit::reference, typename Us::reference> && ...);
|
||||
|
||||
template<typename T>
|
||||
concept Unit =
|
||||
std::is_empty_v<T> &&
|
||||
detail::is_unit<downcast_base_t<T>>;
|
||||
// deduced_unit
|
||||
template<typename Result, int UnitExpNum, int UnitExpDen, typename UnitRatio>
|
||||
struct ratio_op;
|
||||
|
||||
// deduced_derived_unit
|
||||
template<typename Result, int UnitExpDen, typename UnitRatio>
|
||||
struct ratio_op<Result, 0, UnitExpDen, UnitRatio> {
|
||||
using ratio = Result;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
template<typename Result, int UnitExpNum, int UnitExpDen, typename UnitRatio>
|
||||
struct ratio_op {
|
||||
using calc_ratio =
|
||||
conditional<(UnitExpNum * UnitExpDen > 0), ratio_multiply<Result, UnitRatio>, ratio_divide<Result, UnitRatio>>;
|
||||
static constexpr int value = (UnitExpNum * UnitExpDen > 0) ? (UnitExpNum - UnitExpDen) : (UnitExpNum + UnitExpDen);
|
||||
using ratio = ratio_op<calc_ratio, value, UnitExpDen, UnitRatio>::ratio;
|
||||
};
|
||||
|
||||
template<typename D>
|
||||
struct get_unit_base_dim;
|
||||
template<DerivedDimension D, Unit... Us>
|
||||
struct derived_ratio;
|
||||
|
||||
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;
|
||||
};
|
||||
template<Unit... Us>
|
||||
struct derived_ratio<derived_dimension<>, Us...> {
|
||||
using ratio = ::units::ratio<1>;
|
||||
};
|
||||
|
||||
template<typename Result, int UnitExpNum, int UnitExpDen, typename UnitRatio>
|
||||
struct ratio_op;
|
||||
template<typename E, typename... ERest, Unit U, Unit... URest>
|
||||
struct derived_ratio<derived_dimension<E, ERest...>, U, URest...> {
|
||||
using rest_ratio = derived_ratio<derived_dimension<ERest...>, URest...>::ratio;
|
||||
using ratio = ratio_op<rest_ratio, E::num, E::den, typename U::ratio>::ratio;
|
||||
};
|
||||
|
||||
template<typename Result, int UnitExpDen, typename UnitRatio>
|
||||
struct ratio_op<Result, 0, UnitExpDen, UnitRatio> {
|
||||
using ratio = Result;
|
||||
};
|
||||
template<DerivedDimension D, Unit... Us>
|
||||
using deduced_unit =
|
||||
reference_unit<typename D::coherent_unit::reference, typename detail::derived_ratio<typename D::recipe, Us...>::ratio>;
|
||||
|
||||
template<typename Result, int UnitExpNum, int UnitExpDen, typename UnitRatio>
|
||||
struct ratio_op {
|
||||
using calc_ratio = conditional<(UnitExpNum * UnitExpDen > 0), ratio_multiply<Result, UnitRatio>,
|
||||
ratio_divide<Result, UnitRatio>>;
|
||||
static constexpr int value = (UnitExpNum * UnitExpDen > 0) ? (UnitExpNum - UnitExpDen) : (UnitExpNum + UnitExpDen);
|
||||
using ratio = ratio_op<calc_ratio, value, UnitExpDen, UnitRatio>::ratio;
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
template<typename D, typename... Us>
|
||||
struct derived_ratio;
|
||||
/**
|
||||
* @brief A starting point for a new hierarchy of units
|
||||
*
|
||||
* A unit is an entity defined and adopted by convention, with which any other quantity of
|
||||
* the same kind can be compared to express the ratio of the second quantity to the first
|
||||
* one as a number.
|
||||
*
|
||||
* Coherent unit is a unit that, for a given system of quantities and for a chosen set of
|
||||
* base units, is a product of powers of base units with no other proportionality factor
|
||||
* than one.
|
||||
*
|
||||
* This class allows definition of a new unnamed (in most cases coherent) derived unit of
|
||||
* a specific derived dimension and it should be passed in this dimension's definition.
|
||||
*
|
||||
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
|
||||
*/
|
||||
template<typename Child>
|
||||
struct unit : downcast_child<Child, detail::reference_unit<Child, ratio<1>>> {
|
||||
static constexpr bool is_named = false;
|
||||
using prefix_type = no_prefix;
|
||||
};
|
||||
|
||||
template<typename... Us>
|
||||
struct derived_ratio<dimension<>, Us...> {
|
||||
using ratio = ::units::ratio<1>;
|
||||
};
|
||||
/**
|
||||
* @brief A named unit
|
||||
*
|
||||
* Defines a named (in most cases coherent) unit that is then passed to a dimension definition.
|
||||
* A named unit may be used by other units defined with the prefix of the same type, unless
|
||||
* no_prefix is provided for PT template parameter (in such a case it is impossible to define
|
||||
* a prefix unit based on this one).
|
||||
*
|
||||
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
|
||||
* @tparam Symbol a short text representation of the unit
|
||||
* @tparam PT no_prefix or a type of prefix family
|
||||
*/
|
||||
template<typename Child, basic_fixed_string Symbol, PrefixType PT>
|
||||
struct named_unit : downcast_child<Child, detail::reference_unit<Child, ratio<1>>> {
|
||||
static constexpr bool is_named = true;
|
||||
static constexpr auto symbol = Symbol;
|
||||
using prefix_type = PT;
|
||||
};
|
||||
|
||||
template<typename E, typename... ERest, typename U, typename... URest>
|
||||
struct derived_ratio<dimension<E, ERest...>, U, URest...> {
|
||||
static_assert(same_dim<typename E::dimension, typename U::dimension>, "The order and number of units in `deduced_derived_unit<Us...>` should match dimensions provided in a `derived_dimension<>`");
|
||||
static_assert(sizeof...(ERest) == sizeof...(URest), "The number of `deduced_derived_unit<Us...>` units should match the number of exponents provided to `derived_dimension<>`");
|
||||
using rest_ratio = derived_ratio<dimension<ERest...>, URest...>::ratio;
|
||||
using ratio = ratio_op<rest_ratio, E::num, E::den, typename U::ratio>::ratio;
|
||||
};
|
||||
/**
|
||||
* @brief A scaled unit
|
||||
*
|
||||
* Defines a new named unit that is a scaled version of another unit. Such unit can be used by
|
||||
* other units defined with the prefix of the same type, unless no_prefix is provided for PT
|
||||
* template parameter (in such a case it is impossible to define a prefix unit based on this
|
||||
* one).
|
||||
*
|
||||
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
|
||||
* @tparam Symbol a short text representation of the unit
|
||||
* @tparam PT no_prefix or a type of prefix family
|
||||
* @tparam R a scale to apply to U
|
||||
* @tparam U a reference unit to scale
|
||||
*/
|
||||
template<typename Child, basic_fixed_string Symbol, PrefixType PT, Ratio R, Unit U>
|
||||
struct scaled_unit : downcast_child<Child, detail::reference_unit<typename U::reference, ratio_multiply<R, typename U::ratio>>> {
|
||||
static constexpr bool is_named = true;
|
||||
static constexpr auto symbol = Symbol;
|
||||
using prefix_type = PT;
|
||||
};
|
||||
|
||||
template<typename... Es>
|
||||
constexpr auto exp_count(dimension<Es...>)
|
||||
{
|
||||
return sizeof...(Es);
|
||||
}
|
||||
/**
|
||||
* @brief A prefixed unit
|
||||
*
|
||||
* Defines a new unit that is a scaled version of another unit by the provided prefix. It is
|
||||
* only possible to create such a unit if the given prefix type matches the one defined in a
|
||||
* reference unit.
|
||||
*
|
||||
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
|
||||
* @tparam P prefix to be appied to the reference unit
|
||||
* @tparam U reference unit
|
||||
*/
|
||||
template<typename Child, Prefix P, Unit U>
|
||||
requires std::same_as<typename P::prefix_type, typename U::prefix_type>
|
||||
// TODO replace with the below code when gcc will stop to crash on it ;-)
|
||||
// struct prefixed_unit : scaled_unit<Child, P::symbol + U::symbol, typename P::prefix_type,
|
||||
// ratio_multiply<typename P::ratio, typename U::ratio>,
|
||||
// typename U::reference> {};
|
||||
struct prefixed_unit :
|
||||
downcast_child<Child, detail::reference_unit<typename U::reference, ratio_multiply<typename P::ratio, typename U::ratio>>> {
|
||||
static constexpr bool is_named = true;
|
||||
static constexpr auto symbol = P::symbol + U::symbol;
|
||||
using prefix_type = P::prefix_type;
|
||||
};
|
||||
|
||||
template<typename U>
|
||||
inline constexpr bool is_unit_of_base_dimension = (exp_count(typename U::dimension::base_type()) == 1);
|
||||
/**
|
||||
* @brief A unit with a deduced ratio and symbol
|
||||
*
|
||||
* Defines a new unit with a deduced ratio and symbol based on the recipe from the provided
|
||||
* derived dimension. The number and order of provided units should match the recipe of
|
||||
* dimension.
|
||||
*
|
||||
* @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
|
||||
* @tparam Dim a derived dimension recipe to use for deduction
|
||||
* @tparam U the unit of the first composite dimension from provided derived dimension's recipe
|
||||
* @tparam URest the units for the rest of dimensions from the recipe
|
||||
*/
|
||||
template<typename Child, DerivedDimension Dim, Unit U, Unit... URest>
|
||||
requires detail::same_reference_units<typename Dim::recipe, U, URest...> &&
|
||||
(U::is_named && (URest::is_named && ... && true))
|
||||
struct deduced_unit : downcast_child<Child, detail::deduced_unit<Dim, U, URest...>> {
|
||||
static constexpr bool is_named = false;
|
||||
static constexpr auto symbol = basic_fixed_string{""}; // detail::deduced_symbol_text<Dim, U, Us...>();
|
||||
using prefix_type = no_prefix;
|
||||
};
|
||||
|
||||
template<Unit... Us>
|
||||
inline constexpr bool are_units_of_base_dimension = (is_unit_of_base_dimension<Us> && ...);
|
||||
|
||||
template<Dimension D, Unit... Us>
|
||||
using deduced_derived_unit =
|
||||
unit<D, typename detail::derived_ratio<std::conditional_t<are_units_of_base_dimension<Us...>,
|
||||
typename D::base_type, typename D::recipe>, Us...>::ratio>;
|
||||
|
||||
template<int Value>
|
||||
requires (0 <= Value) && (Value < 10)
|
||||
inline constexpr basic_fixed_string superscript_number = "\u2070";
|
||||
|
||||
// template<> inline constexpr basic_fixed_string superscript_number<0> = "\u2070";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<1> = "\u00b9";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<2> = "\u00b2";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<3> = "\u00b3";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<4> = "\u2074";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<5> = "\u2075";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<6> = "\u2076";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<7> = "\u2077";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<8> = "\u2078";
|
||||
template<> inline constexpr basic_fixed_string superscript_number<9> = "\u2079";
|
||||
|
||||
template<int Value>
|
||||
requires (Value >= 0)
|
||||
constexpr auto superscript()
|
||||
{
|
||||
if constexpr(Value < 10)
|
||||
return superscript_number<Value>;
|
||||
else
|
||||
return superscript<Value / 10>() + superscript<Value % 10>();
|
||||
}
|
||||
|
||||
template<int Value>
|
||||
requires (Value >= 0)
|
||||
constexpr auto regular()
|
||||
{
|
||||
if constexpr(Value < 10)
|
||||
return basic_fixed_string(static_cast<char>('0' + Value));
|
||||
else
|
||||
return regular<Value / 10>() + regular<Value % 10>();
|
||||
}
|
||||
|
||||
|
||||
template<typename Ratio>
|
||||
constexpr auto ratio_text()
|
||||
{
|
||||
if constexpr(Ratio::num != 1 || Ratio::den != 1) {
|
||||
auto txt = basic_fixed_string("[") + regular<Ratio::num>();
|
||||
if constexpr(Ratio::den == 1) {
|
||||
return txt + basic_fixed_string("]");
|
||||
}
|
||||
else {
|
||||
return txt + basic_fixed_string("/") + regular<Ratio::den>() + basic_fixed_string("]");
|
||||
}
|
||||
}
|
||||
else {
|
||||
return basic_fixed_string("");
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Ratio, typename PrefixType>
|
||||
constexpr auto prefix_or_ratio_text()
|
||||
{
|
||||
if constexpr(Ratio::num != 1 || Ratio::den != 1) {
|
||||
if constexpr (!std::same_as<PrefixType, no_prefix>) {
|
||||
using prefix = downcast<detail::prefix_base<PrefixType, Ratio>>;
|
||||
|
||||
if constexpr(!std::same_as<prefix, prefix_base<PrefixType, Ratio>>) {
|
||||
// print as a prefixed unit
|
||||
return prefix::symbol;
|
||||
}
|
||||
else {
|
||||
// print as a ratio of the coherent unit
|
||||
return ratio_text<Ratio>();
|
||||
}
|
||||
}
|
||||
else {
|
||||
// print as a ratio of the coherent unit
|
||||
return ratio_text<Ratio>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<bool Divide, std::size_t Idx>
|
||||
constexpr auto operator_text()
|
||||
{
|
||||
if constexpr(Idx == 0) {
|
||||
if constexpr(Divide) {
|
||||
return basic_fixed_string("1/");
|
||||
}
|
||||
else {
|
||||
return basic_fixed_string("");
|
||||
}
|
||||
}
|
||||
else {
|
||||
if constexpr(Divide) {
|
||||
return basic_fixed_string("/");
|
||||
}
|
||||
else {
|
||||
return basic_fixed_string("⋅");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<typename E, basic_fixed_string Symbol, std::size_t Idx>
|
||||
constexpr auto exp_text()
|
||||
{
|
||||
// get calculation operator + symbol
|
||||
const auto txt = operator_text<E::num < 0, Idx>() + Symbol;
|
||||
if constexpr(E::den != 1) {
|
||||
// add root part
|
||||
return txt + basic_fixed_string("^(") + regular<abs(E::num)>() + basic_fixed_string("/") + regular<E::den>() + basic_fixed_string(")");
|
||||
}
|
||||
else if constexpr(abs(E::num) != 1) {
|
||||
// add exponent part
|
||||
return txt + superscript<abs(E::num)>();
|
||||
}
|
||||
else {
|
||||
return txt;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Dim>
|
||||
constexpr auto dimension_symbol()
|
||||
{
|
||||
if constexpr(BaseDimension<Dim>)
|
||||
return Dim::symbol;
|
||||
else
|
||||
// coherent derived unit
|
||||
return downcast<unit<Dim, ratio<1>>>::symbol;
|
||||
}
|
||||
|
||||
template<typename... Es, std::size_t... Idxs>
|
||||
constexpr auto base_symbol_text_impl(dimension<Es...>, std::index_sequence<Idxs...>)
|
||||
{
|
||||
return (exp_text<Es, dimension_symbol<typename Es::dimension>(), Idxs>() + ...);
|
||||
}
|
||||
|
||||
template<typename... Es>
|
||||
constexpr auto base_symbol_text(dimension<Es...> d)
|
||||
{
|
||||
return base_symbol_text_impl(d, std::index_sequence_for<Es...>());
|
||||
}
|
||||
|
||||
template<typename... Es>
|
||||
constexpr bool all_named(dimension<Es...>)
|
||||
{
|
||||
return (downcast<unit<typename Es::dimension, ratio<1>>>::is_named && ...);
|
||||
}
|
||||
|
||||
template<typename Dim>
|
||||
constexpr auto base_symbol_text()
|
||||
{
|
||||
using recipe = typename Dim::recipe;
|
||||
if constexpr(all_named(recipe()))
|
||||
return base_symbol_text(recipe());
|
||||
else
|
||||
return base_symbol_text(Dim());
|
||||
}
|
||||
|
||||
template<typename E, typename U, std::size_t Idx>
|
||||
constexpr auto exp_validate_and_text()
|
||||
{
|
||||
static_assert(same_dim<typename E::dimension, typename U::dimension>, "The order and number of units in `deduced_derived_unit<Us...>` should match dimensions provided in a `derived_dimension<>`");
|
||||
return exp_text<E, U::symbol, Idx>();
|
||||
}
|
||||
|
||||
template<typename... Us, typename... Es, std::size_t... Idxs>
|
||||
constexpr auto deduced_symbol_text_impl(dimension<Es...>, std::index_sequence<Idxs...>)
|
||||
{
|
||||
return (exp_validate_and_text<Es, Us, Idxs>() + ...);
|
||||
}
|
||||
|
||||
template<typename... Us, typename... Es>
|
||||
constexpr auto deduced_symbol_text(dimension<Es...> d)
|
||||
{
|
||||
static_assert(sizeof...(Es) == sizeof...(Us), "The number of `deduced_derived_unit<Us...>` units should match the number of exponents provided to `derived_dimension<>`");
|
||||
return deduced_symbol_text_impl<Us...>(d, std::index_sequence_for<Es...>());
|
||||
}
|
||||
|
||||
template<typename Dim, typename... Us>
|
||||
constexpr auto deduced_symbol_text()
|
||||
{
|
||||
if constexpr(are_units_of_base_dimension<Us...>)
|
||||
return deduced_symbol_text<Us...>(typename Dim::base_type());
|
||||
else
|
||||
return deduced_symbol_text<Us...>(typename Dim::recipe());
|
||||
}
|
||||
|
||||
template<typename Unit>
|
||||
constexpr auto unit_text()
|
||||
{
|
||||
if constexpr(!is_unit<Unit>) {
|
||||
// Unit is a downcasted derived unit child class already so just print defined symbol immediately
|
||||
return Unit::symbol;
|
||||
}
|
||||
else {
|
||||
// we are dealing with a non-user-defined unit here
|
||||
using ratio = Unit::ratio;
|
||||
using dim = Unit::dimension;
|
||||
if constexpr(!is_dimension<dim>) {
|
||||
// downcasted user-defined dimension
|
||||
// print as a prefix or ratio of a coherent unit symbol defined by the user
|
||||
using coherent_unit = downcast<units::unit<dim, units::ratio<1>>>;
|
||||
return prefix_or_ratio_text<ratio, typename coherent_unit::prefix_type>() + coherent_unit::symbol;
|
||||
}
|
||||
else {
|
||||
// print as a ratio of a coherent unit + coherent unit dimensions and their exponents
|
||||
return ratio_text<ratio>() + base_symbol_text(dim{});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
|
||||
// derived_unit
|
||||
|
||||
template<typename Child, Dimension Dim, basic_fixed_string Symbol, PrefixType PT>
|
||||
struct named_coherent_derived_unit : downcast_child<Child, unit<Dim, ratio<1>>> {
|
||||
static constexpr bool is_named = true;
|
||||
static constexpr auto symbol = Symbol;
|
||||
using prefix_type = PT;
|
||||
};
|
||||
|
||||
template<typename Child, Dimension Dim>
|
||||
struct coherent_derived_unit : downcast_child<Child, unit<Dim, ratio<1>>> {
|
||||
static constexpr bool is_named = false;
|
||||
static constexpr auto symbol = detail::base_symbol_text<Dim>();
|
||||
using prefix_type = no_prefix;
|
||||
};
|
||||
|
||||
template<typename Child, Dimension Dim, basic_fixed_string Symbol, Ratio R, PrefixType PT = no_prefix>
|
||||
struct named_scaled_derived_unit : downcast_child<Child, unit<Dim, R>> {
|
||||
static constexpr bool is_named = true;
|
||||
static constexpr auto symbol = Symbol;
|
||||
using prefix_type = PT;
|
||||
};
|
||||
|
||||
template<typename Child, Dimension Dim, basic_fixed_string Symbol, PrefixType PT, Unit U, Unit... Us>
|
||||
struct named_deduced_derived_unit : downcast_child<Child, detail::deduced_derived_unit<Dim, U, Us...>> {
|
||||
static constexpr bool is_named = true;
|
||||
static constexpr auto symbol = Symbol;
|
||||
using prefix_type = PT;
|
||||
};
|
||||
|
||||
template<typename Child, Dimension Dim, Unit U, Unit... Us>
|
||||
requires U::is_named && (Us::is_named && ... && true)
|
||||
struct deduced_derived_unit : downcast_child<Child, detail::deduced_derived_unit<Dim, U, Us...>> {
|
||||
static constexpr bool is_named = false;
|
||||
static constexpr auto symbol = detail::deduced_symbol_text<Dim, U, Us...>();
|
||||
using prefix_type = no_prefix;
|
||||
};
|
||||
|
||||
template<typename Child, Prefix P, Unit U>
|
||||
requires (!std::same_as<typename U::prefix_type, no_prefix>)
|
||||
struct prefixed_derived_unit : downcast_child<Child, unit<typename U::dimension, ratio_multiply<typename P::ratio, typename U::ratio>>> {
|
||||
static constexpr bool is_named = true;
|
||||
static constexpr auto symbol = P::symbol + U::symbol;
|
||||
using prefix_type = P::prefix_type;
|
||||
};
|
||||
// template<typename Child, Dimension Dim, basic_fixed_string Symbol, PrefixType PT, Unit U, Unit... Us>
|
||||
// struct named_deduced_derived_unit : downcast_child<Child, detail::deduced_derived_unit<Dim, U, Us...>> {
|
||||
// static constexpr bool is_named = true;
|
||||
// static constexpr auto symbol = Symbol;
|
||||
// using prefix_type = PT;
|
||||
// };
|
||||
|
||||
} // namespace units
|
||||
|
||||
@ -20,6 +20,6 @@
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
|
||||
add_subdirectory(unit_test/runtime)
|
||||
#add_subdirectory(unit_test/runtime)
|
||||
add_subdirectory(unit_test/static)
|
||||
add_subdirectory(metabench)
|
||||
#add_subdirectory(metabench)
|
||||
|
||||
@ -21,13 +21,16 @@
|
||||
# SOFTWARE.
|
||||
|
||||
add_library(unit_tests_static
|
||||
cgs_test.cpp
|
||||
custom_unit_test.cpp
|
||||
dimension_test.cpp
|
||||
math_test.cpp
|
||||
quantity_test.cpp
|
||||
# cgs_test.cpp
|
||||
# custom_unit_test.cpp
|
||||
# dimension_test.cpp
|
||||
# fixed_string_test.cpp
|
||||
# math_test.cpp
|
||||
# new_design.cpp
|
||||
# quantity_test.cpp
|
||||
ratio_test.cpp
|
||||
type_list_test.cpp
|
||||
# si_test.cpp
|
||||
# type_list_test.cpp
|
||||
unit_test.cpp
|
||||
)
|
||||
target_link_libraries(unit_tests_static
|
||||
|
||||
@ -1,28 +1,28 @@
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
// The MIT License (MIT)
|
||||
//
|
||||
// Copyright (c) 2018 Mateusz Pusz
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#include "units/ratio.h"
|
||||
#include "units/ratio.h"
|
||||
|
||||
namespace {
|
||||
namespace {
|
||||
|
||||
using namespace units;
|
||||
|
||||
@ -31,6 +31,8 @@ namespace {
|
||||
|
||||
static_assert(same<ratio<2, 4>, ratio<1, 2>>);
|
||||
|
||||
static_assert(std::is_same_v<ratio_multiply<ratio<1>, ratio<3, 8>>, ratio<3, 8>>);
|
||||
static_assert(std::is_same_v<ratio_multiply<ratio<3, 8>, ratio<1>>, ratio<3, 8>>);
|
||||
static_assert(std::is_same_v<ratio_multiply<ratio<4>, ratio<1, 8>>, ratio<1, 2>>);
|
||||
static_assert(std::is_same_v<ratio_multiply<ratio<4>, ratio<1, 2>>, ratio<2>>);
|
||||
static_assert(std::is_same_v<ratio_multiply<ratio<1, 8>, ratio<2>>, ratio<1, 4>>);
|
||||
@ -63,4 +65,4 @@ namespace {
|
||||
static_assert(std::is_same_v<common_ratio<ratio<1>, ratio<1, 1000>>, ratio<1, 1000>>);
|
||||
static_assert(std::is_same_v<common_ratio<ratio<1, 1000>, ratio<1>>, ratio<1, 1000>>);
|
||||
|
||||
} // namespace
|
||||
} // namespace
|
||||
@ -20,174 +20,36 @@
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#include <units/dimensions/acceleration.h>
|
||||
#include <units/dimensions/area.h>
|
||||
#include <units/dimensions/capacitance.h>
|
||||
#include <units/dimensions/current.h>
|
||||
#include <units/dimensions/electric_charge.h>
|
||||
#include <units/dimensions/energy.h>
|
||||
#include <units/dimensions/force.h>
|
||||
#include <units/dimensions/frequency.h>
|
||||
#include <units/dimensions/length.h>
|
||||
#include <units/dimensions/luminous_intensity.h>
|
||||
#include <units/dimensions/mass.h>
|
||||
#include <units/dimensions/power.h>
|
||||
#include <units/dimensions/pressure.h>
|
||||
#include <units/dimensions/substance.h>
|
||||
#include <units/dimensions/surface_tension.h>
|
||||
#include <units/dimensions/temperature.h>
|
||||
#include <units/dimensions/time.h>
|
||||
#include <units/dimensions/velocity.h>
|
||||
#include <units/dimensions/voltage.h>
|
||||
#include <units/dimensions/volume.h>
|
||||
|
||||
#include <utility>
|
||||
#include "units/unit.h"
|
||||
#include "units/physical/si/prefixes.h"
|
||||
|
||||
namespace {
|
||||
|
||||
using namespace units;
|
||||
using namespace units;
|
||||
|
||||
/* ************** BASE DIMENSIONS **************** */
|
||||
struct metre : named_unit<metre, "m", si::prefix> {};
|
||||
struct centimetre : prefixed_unit<centimetre, si::centi, metre> {};
|
||||
struct kilometre : prefixed_unit<kilometre, si::kilo, metre> {};
|
||||
struct yard : scaled_unit<yard, "yd", no_prefix, ratio<9'144, 10'000>, metre> {};
|
||||
struct foot : scaled_unit<foot, "ft", no_prefix, ratio<1, 3>, yard> {};
|
||||
struct dim_length : base_dimension<"length", metre> {};
|
||||
|
||||
// length
|
||||
struct second : named_unit<second, "s", si::prefix> {};
|
||||
struct hour : scaled_unit<hour, "h", no_prefix, ratio<3600>, second> {};
|
||||
struct dim_time : base_dimension<"time", second> {};
|
||||
|
||||
static_assert(1km == 1000m);
|
||||
static_assert(1m == 100cm);
|
||||
static_assert(1m == 1000mm);
|
||||
static_assert(1km + 1m == 1001m);
|
||||
static_assert(10km / 5km == 2);
|
||||
static_assert(100mm / 5cm == 2);
|
||||
static_assert(10km / 2 == 5km);
|
||||
struct metre_per_second : unit<metre_per_second> {};
|
||||
struct dim_velocity : derived_dimension<dim_velocity, metre_per_second, exp<dim_length, 1>, exp<dim_time, -1>> {};
|
||||
struct kilometre_per_hour : deduced_unit<kilometre_per_hour, dim_velocity, kilometre, hour> {};
|
||||
|
||||
static_assert(1yd == 0.9144m);
|
||||
static_assert(1yd == 3ft);
|
||||
static_assert(1ft == 12in);
|
||||
static_assert(1mi == 1760yd);
|
||||
static_assert(std::is_same_v<downcast<detail::reference_unit<metre, ratio<1>>>, metre>);
|
||||
static_assert(std::is_same_v<downcast<detail::reference_unit<metre, ratio<1, 100>>>, centimetre>);
|
||||
static_assert(std::is_same_v<downcast<detail::reference_unit<metre, ratio<yard::ratio::num, yard::ratio::den>>>, yard>);
|
||||
static_assert(std::is_same_v<downcast<detail::reference_unit<metre, ratio_multiply<typename yard::ratio, ratio<1, 3>>>>, foot>);
|
||||
static_assert(std::is_same_v<downcast<detail::reference_unit<metre_per_second, ratio_divide<typename kilometre::ratio, typename hour::ratio>>>, kilometre_per_hour>);
|
||||
|
||||
static_assert(5in + 8cm == 207mm);
|
||||
|
||||
static_assert(millimetre::symbol == "mm");
|
||||
static_assert(centimetre::symbol == "cm");
|
||||
static_assert(kilometre::symbol == "km");
|
||||
|
||||
// mass
|
||||
|
||||
static_assert(1kg == 1000g);
|
||||
|
||||
static_assert(kilogram::symbol == "kg");
|
||||
|
||||
// time
|
||||
|
||||
static_assert(1h == 3600s);
|
||||
|
||||
static_assert(nanosecond::symbol == "ns");
|
||||
static_assert(microsecond::symbol == "µs");
|
||||
static_assert(millisecond::symbol == "ms");
|
||||
|
||||
// current
|
||||
|
||||
// temperature
|
||||
|
||||
// substance
|
||||
|
||||
// luminous intensity
|
||||
|
||||
|
||||
/* ************** DERIVED DIMENSIONS WITH NAMED UNITS **************** */
|
||||
|
||||
// frequency
|
||||
|
||||
static_assert(2 / 1s == 2Hz);
|
||||
static_assert(120 / 1min == 2Hz);
|
||||
static_assert(1000 / 1s == 1kHz);
|
||||
static_assert(1 / 1ms == 1kHz);
|
||||
static_assert(3.2GHz == 3'200'000'000Hz);
|
||||
static_assert(10Hz * 1min == 600);
|
||||
|
||||
static_assert(millihertz::symbol == "mHz");
|
||||
static_assert(kilohertz::symbol == "kHz");
|
||||
static_assert(megahertz::symbol == "MHz");
|
||||
static_assert(gigahertz::symbol == "GHz");
|
||||
static_assert(terahertz::symbol == "THz");
|
||||
|
||||
// force
|
||||
|
||||
static_assert(10kg * 10mps_sq == 100N);
|
||||
|
||||
// pressure
|
||||
|
||||
static_assert(10N / 10sq_m == 1Pa);
|
||||
|
||||
// energy
|
||||
|
||||
static_assert(10N * 10m == 100_J);
|
||||
static_assert(10Pa * 10cub_m == 100_J);
|
||||
|
||||
// power
|
||||
|
||||
static_assert(10_J / 10s == 1W);
|
||||
|
||||
// electric charge
|
||||
|
||||
static_assert(10A * 10s == 100C);
|
||||
|
||||
// voltage
|
||||
|
||||
static_assert(10W / 10A == 1V);
|
||||
static_assert(10_J / 10C == 1V);
|
||||
|
||||
// capacitance
|
||||
|
||||
static_assert(10C / 10V == 1F);
|
||||
|
||||
/* ************** DERIVED DIMENSIONS IN TERMS OF BASE UNITS **************** */
|
||||
|
||||
// velocity
|
||||
|
||||
static_assert(std::is_same_v<decltype(1km / 1s), quantity<unit<velocity, ratio<1000, 1>>, std::int64_t>>);
|
||||
|
||||
static_assert(10m / 5s == 2mps);
|
||||
static_assert(10 / 5s * 1m == 2mps);
|
||||
static_assert(1km / 1s == 1000mps);
|
||||
// static_assert(1km / 1h == 1kmph); // should not compile
|
||||
static_assert(1.0km / 1h == 1kmph);
|
||||
static_assert(1000.0m / 3600.0s == 1kmph);
|
||||
|
||||
static_assert(10.0mi / 2h == 5mph);
|
||||
|
||||
static_assert(2kmph * 2h == 4km);
|
||||
// static_assert(2kmph * 15min == 500m); // should not compile
|
||||
static_assert(2kmph * 15.0min == 500m);
|
||||
static_assert(2.0kmph * 15min == 500m);
|
||||
|
||||
static_assert(2km / 2kmph == 1h);
|
||||
// static_assert(2000m / 2kmph == 1h); // should not compile
|
||||
static_assert(quantity_cast<quantity<kilometre, int>>(2000m) / 2kmph == 1h);
|
||||
|
||||
// static_assert(metre_per_second::symbol == basic_fixed_string("m/s"));
|
||||
// static_assert(kilometre_per_hour::symbol == basic_fixed_string("km/h"));
|
||||
|
||||
|
||||
// acceleration
|
||||
|
||||
static_assert(10mps / 10s == 1mps_sq);
|
||||
|
||||
// area
|
||||
|
||||
static_assert(1m * 1m == 1sq_m);
|
||||
static_assert(10km * 10km == 100sq_km);
|
||||
static_assert(1sq_m == 10'000sq_cm);
|
||||
|
||||
// volume
|
||||
|
||||
static_assert(1m * 1m * 1m == 1cub_m);
|
||||
static_assert(10sq_m * 10m == 100cub_m);
|
||||
static_assert(10km * 10km * 10km == 1000cub_km);
|
||||
static_assert(1cub_m == 1'000'000cub_cm);
|
||||
|
||||
|
||||
/* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */
|
||||
|
||||
static_assert(10N / 2m == 5Npm);
|
||||
static_assert(centimetre::symbol == "cm");
|
||||
static_assert(kilometre::symbol == "km");
|
||||
static_assert(kilometre_per_hour::symbol == "");
|
||||
|
||||
} // namespace
|
||||
|
||||
Reference in New Issue
Block a user