mirror of
https://github.com/mpusz/mp-units.git
synced 2025-08-04 12:54:25 +02:00
Custom unit and data tests enabled
This commit is contained in:
Mateusz Pusz
59
src/include/units/data/bitrate.h
Normal file
59
src/include/units/data/bitrate.h
Normal file
@@ -0,0 +1,59 @@
|
||||
// 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/data/information.h>
|
||||
#include <units/derived_dimension.h>
|
||||
#include <units/physical/si/time.h>
|
||||
#include <units/quantity.h>
|
||||
|
||||
namespace units::data {
|
||||
|
||||
struct bit_per_second : unit<bit_per_second> {};
|
||||
struct dim_bitrate : derived_dimension<dim_bitrate, bit_per_second, exp<dim_information, 1>, exp<si::dim_time, -1>> {};
|
||||
|
||||
struct kibibit_per_second : deduced_unit<kibibit_per_second, dim_bitrate, kibibit, si::second> {};
|
||||
struct mebibit_per_second : deduced_unit<mebibit_per_second, dim_bitrate, mebibit, si::second> {};
|
||||
struct gibibit_per_second : deduced_unit<gibibit_per_second, dim_bitrate, gibibit, si::second> {};
|
||||
struct tebibit_per_second : deduced_unit<tebibit_per_second, dim_bitrate, tebibit, si::second> {};
|
||||
struct pebibit_per_second : deduced_unit<pebibit_per_second, dim_bitrate, pebibit, si::second> {};
|
||||
|
||||
template<typename T>
|
||||
concept Bitrate = QuantityOf<T, dim_bitrate>;
|
||||
|
||||
template<Unit U, Scalar Rep = double>
|
||||
using bitrate = quantity<dim_bitrate, U, Rep>;
|
||||
|
||||
inline namespace literals {
|
||||
|
||||
// bits
|
||||
constexpr auto operator""_bps(unsigned long long l) { return bitrate<bit_per_second, std::int64_t>(l); }
|
||||
constexpr auto operator""_Kibps(unsigned long long l) { return bitrate<kibibit_per_second, std::int64_t>(l); }
|
||||
constexpr auto operator""_Mibps(unsigned long long l) { return bitrate<mebibit_per_second, std::int64_t>(l); }
|
||||
constexpr auto operator""_Gibps(unsigned long long l) { return bitrate<gibibit_per_second, std::int64_t>(l); }
|
||||
constexpr auto operator""_Tibps(unsigned long long l) { return bitrate<tebibit_per_second, std::int64_t>(l); }
|
||||
constexpr auto operator""_Pibps(unsigned long long l) { return bitrate<pebibit_per_second, std::int64_t>(l); }
|
||||
|
||||
} // namespace literals
|
||||
|
||||
} // namespace units::data
|
||||
74
src/include/units/data/information.h
Normal file
74
src/include/units/data/information.h
Normal file
@@ -0,0 +1,74 @@
|
||||
// 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/data/prefixes.h>
|
||||
#include <units/unit.h>
|
||||
#include <units/quantity.h>
|
||||
|
||||
namespace units::data {
|
||||
|
||||
struct bit : named_unit<bit, "b", prefix> {};
|
||||
struct kibibit : prefixed_unit<kibibit, kibi, bit> {};
|
||||
struct mebibit : prefixed_unit<mebibit, mebi, bit> {};
|
||||
struct gibibit : prefixed_unit<gibibit, gibi, bit> {};
|
||||
struct tebibit : prefixed_unit<tebibit, tebi, bit> {};
|
||||
struct pebibit : prefixed_unit<pebibit, pebi, bit> {};
|
||||
|
||||
struct byte : named_scaled_unit<byte, "B", prefix, ratio<8>, bit> {};
|
||||
struct kibibyte : prefixed_unit<kibibyte, kibi, byte> {};
|
||||
struct mebibyte : prefixed_unit<mebibyte, mebi, byte> {};
|
||||
struct gibibyte : prefixed_unit<gibibyte, gibi, byte> {};
|
||||
struct tebibyte : prefixed_unit<tebibyte, tebi, byte> {};
|
||||
struct pebibyte : prefixed_unit<pebibyte, pebi, byte> {};
|
||||
|
||||
struct dim_information : base_dimension<"information", bit> {};
|
||||
|
||||
template<typename T>
|
||||
concept Information = QuantityOf<T, dim_information>;
|
||||
|
||||
template<Unit U, Scalar Rep = double>
|
||||
using information = quantity<dim_information, U, Rep>;
|
||||
|
||||
inline namespace literals {
|
||||
|
||||
// bits
|
||||
constexpr auto operator""b(unsigned long long l) { return information<bit, std::int64_t>(l); }
|
||||
constexpr auto operator""Kib(unsigned long long l) { return information<kibibit, std::int64_t>(l); }
|
||||
constexpr auto operator""Mib(unsigned long long l) { return information<mebibit, std::int64_t>(l); }
|
||||
constexpr auto operator""Gib(unsigned long long l) { return information<gibibit, std::int64_t>(l); }
|
||||
constexpr auto operator""Tib(unsigned long long l) { return information<tebibit, std::int64_t>(l); }
|
||||
constexpr auto operator""Pib(unsigned long long l) { return information<pebibit, std::int64_t>(l); }
|
||||
|
||||
// bytes
|
||||
constexpr auto operator""B(unsigned long long l) { return information<byte, std::int64_t>(l); }
|
||||
constexpr auto operator""KiB(unsigned long long l) { return information<kibibyte, std::int64_t>(l); }
|
||||
constexpr auto operator""MiB(unsigned long long l) { return information<mebibyte, std::int64_t>(l); }
|
||||
constexpr auto operator""GiB(unsigned long long l) { return information<gibibyte, std::int64_t>(l); }
|
||||
constexpr auto operator""TiB(unsigned long long l) { return information<tebibyte, std::int64_t>(l); }
|
||||
constexpr auto operator""PiB(unsigned long long l) { return information<pebibyte, std::int64_t>(l); }
|
||||
|
||||
} // namespace literals
|
||||
|
||||
} // namespace units::data
|
||||
38
src/include/units/data/prefixes.h
Normal file
38
src/include/units/data/prefixes.h
Normal file
@@ -0,0 +1,38 @@
|
||||
// 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::data {
|
||||
|
||||
struct prefix : prefix_type {};
|
||||
|
||||
struct kibi : units::prefix<kibi, prefix, "Ki", ratio< 1'024>> {};
|
||||
struct mebi : units::prefix<mebi, prefix, "Mi", ratio< 1'048'576>> {};
|
||||
struct gibi : units::prefix<gibi, prefix, "Gi", ratio< 1'073'741'824>> {};
|
||||
struct tebi : units::prefix<tebi, prefix, "Ti", ratio< 1'099'511'627'776>> {};
|
||||
struct pebi : units::prefix<pebi, prefix, "Pi", ratio<1'125'899'906'842'624>> {};
|
||||
|
||||
} // namespace units::si
|
||||
@@ -199,7 +199,7 @@ struct dimension_pow_impl<derived_dimension<exp<D, 1, N>>, N> {
|
||||
|
||||
template<DerivedDimension D, std::size_t N>
|
||||
struct dimension_pow_impl<D, N> {
|
||||
using type = dimension_pow_impl<downcast_base<D>, N>;
|
||||
using type = dimension_pow_impl<downcast_base_t<D>, N>::type;
|
||||
};
|
||||
|
||||
template<typename... Es, std::size_t N>
|
||||
|
||||
@@ -29,7 +29,7 @@
|
||||
|
||||
namespace units {
|
||||
|
||||
inline namespace physical {
|
||||
namespace physical {
|
||||
|
||||
template<typename Dim, template<typename...> typename DimTemplate>
|
||||
concept DimensionOf = (Dimension<Dim> || BaseDimension<Dim>) && is_derived_from_instantiation<Dim, DimTemplate>;
|
||||
@@ -39,148 +39,128 @@ concept QuantityOf = Quantity<Q> && is_derived_from_instantiation<typename Q::di
|
||||
|
||||
// ------------------------ base dimensions -----------------------------
|
||||
|
||||
// length
|
||||
template<Unit U>
|
||||
struct dim_length : base_dimension<"length", U> {};
|
||||
|
||||
template<typename T>
|
||||
concept Length = QuantityOf<T, dim_length>;
|
||||
|
||||
// mass
|
||||
template<Unit U>
|
||||
struct dim_mass : base_dimension<"mass", U> {};
|
||||
|
||||
template<typename T>
|
||||
concept Mass = QuantityOf<T, dim_mass>;
|
||||
|
||||
// time
|
||||
template<Unit U>
|
||||
struct dim_time : base_dimension<"time", U> {};
|
||||
|
||||
template<typename T>
|
||||
concept Time = QuantityOf<T, dim_time>;
|
||||
|
||||
// current
|
||||
template<Unit U>
|
||||
struct dim_current : base_dimension<"current", U> {};
|
||||
|
||||
template<typename T>
|
||||
concept Current = QuantityOf<T, dim_current>;
|
||||
|
||||
// temperature
|
||||
template<Unit U>
|
||||
struct dim_temperature : base_dimension<"temperature", U> {};
|
||||
|
||||
template<typename T>
|
||||
concept Temperature = QuantityOf<T, dim_temperature>;
|
||||
|
||||
// substance
|
||||
template<Unit U>
|
||||
struct dim_substance : base_dimension<"substance", U> {};
|
||||
|
||||
template<typename T>
|
||||
concept Substance = QuantityOf<T, dim_substance>;
|
||||
|
||||
// luminous intensity
|
||||
template<Unit U>
|
||||
struct dim_luminous_intensity : base_dimension<"luminous intensity", U> {};
|
||||
|
||||
template<typename T>
|
||||
concept LuminousIntensity = QuantityOf<T, dim_luminous_intensity>;
|
||||
|
||||
// ------------------------ derived dimensions -----------------------------
|
||||
|
||||
// frequency
|
||||
template<typename Child, Unit U, DimensionOf<dim_time> T>
|
||||
struct dim_frequency : derived_dimension<Child, U, exp<T, -1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Frequency = QuantityOf<T, dim_frequency>;
|
||||
|
||||
// area
|
||||
template<typename Child, Unit U, DimensionOf<dim_length> L>
|
||||
struct dim_area : derived_dimension<Child, U, exp<L, 2>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Area = QuantityOf<T, dim_area>;
|
||||
|
||||
// volume
|
||||
template<typename Child, Unit U, DimensionOf<dim_length> L>
|
||||
struct dim_volume : derived_dimension<Child, U, exp<L, 3>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Volume = QuantityOf<T, dim_volume>;
|
||||
|
||||
// velocity
|
||||
template<typename Child, Unit U, DimensionOf<dim_length> L, DimensionOf<dim_time> T>
|
||||
struct dim_velocity : derived_dimension<Child, U, exp<L, 1>, exp<T, -1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Velocity = QuantityOf<T, dim_velocity>;
|
||||
|
||||
// acceleration
|
||||
template<typename Child, Unit U, DimensionOf<dim_length> L, DimensionOf<dim_time> T>
|
||||
struct dim_acceleration : derived_dimension<Child, U, exp<L, 1>, exp<T, -2>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Acceleration = QuantityOf<T, dim_acceleration>;
|
||||
|
||||
// force
|
||||
template<typename Child, Unit U, DimensionOf<dim_mass> M, DimensionOf<dim_acceleration> A>
|
||||
struct dim_force : derived_dimension<Child, U, exp<M, 1>, exp<A, 1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Force = QuantityOf<T, dim_force>;
|
||||
|
||||
// energy
|
||||
template<typename Child, Unit U, DimensionOf<dim_force> F, DimensionOf<dim_length> L>
|
||||
struct dim_energy : derived_dimension<Child, U, exp<F, 1>, exp<L, 1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Energy = QuantityOf<T, dim_energy>;
|
||||
|
||||
// power
|
||||
template<typename Child, Unit U, DimensionOf<dim_energy> E, DimensionOf<dim_time> T>
|
||||
struct dim_power : derived_dimension<Child, U, exp<E, 1>, exp<T, -1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Power = QuantityOf<T, dim_power>;
|
||||
|
||||
// voltage
|
||||
template<typename Child, Unit U, DimensionOf<dim_power> P, DimensionOf<dim_current> C>
|
||||
struct dim_voltage : derived_dimension<Child, U, exp<P, 1>, exp<C, -1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Voltage = QuantityOf<T, dim_voltage>;
|
||||
|
||||
// electric charge
|
||||
template<typename Child, Unit U, DimensionOf<dim_time> T, DimensionOf<dim_current> C>
|
||||
struct dim_electric_charge : derived_dimension<Child, U, exp<T, 1>, exp<C, 1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept ElectricCharge = QuantityOf<T, dim_electric_charge>;
|
||||
|
||||
// capacitance
|
||||
template<typename Child, Unit U, DimensionOf<dim_electric_charge> C, DimensionOf<dim_voltage> V>
|
||||
struct dim_capacitance : derived_dimension<Child, U, exp<C, 1>, exp<V, -1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Capacitance = QuantityOf<T, dim_capacitance>;
|
||||
|
||||
// surface tension
|
||||
template<typename Child, Unit U, DimensionOf<dim_force> F, DimensionOf<dim_length> L>
|
||||
struct dim_surface_tension : derived_dimension<Child, U, exp<F, 1>, exp<L, -1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept SurfaceTension = QuantityOf<T, dim_surface_tension>;
|
||||
|
||||
// pressure
|
||||
template<typename Child, Unit U, DimensionOf<dim_force> F, DimensionOf<dim_area> A>
|
||||
struct dim_pressure : derived_dimension<Child, U, exp<F, 1>, exp<A, -1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept Pressure = QuantityOf<T, dim_pressure>;
|
||||
|
||||
} // namespace physical
|
||||
|
||||
template<typename T>
|
||||
concept Length = physical::QuantityOf<T, physical::dim_length>;
|
||||
|
||||
template<typename T>
|
||||
concept Mass = physical::QuantityOf<T, physical::dim_mass>;
|
||||
|
||||
template<typename T>
|
||||
concept Time = physical::QuantityOf<T, physical::dim_time>;
|
||||
|
||||
template<typename T>
|
||||
concept Current = physical::QuantityOf<T, physical::dim_current>;
|
||||
|
||||
template<typename T>
|
||||
concept Temperature = physical::QuantityOf<T, physical::dim_temperature>;
|
||||
|
||||
template<typename T>
|
||||
concept Substance = physical::QuantityOf<T, physical::dim_substance>;
|
||||
|
||||
template<typename T>
|
||||
concept LuminousIntensity = physical::QuantityOf<T, physical::dim_luminous_intensity>;
|
||||
|
||||
template<typename T>
|
||||
concept Frequency = physical::QuantityOf<T, physical::dim_frequency>;
|
||||
|
||||
template<typename T>
|
||||
concept Area = physical::QuantityOf<T, physical::dim_area>;
|
||||
|
||||
template<typename T>
|
||||
concept Volume = physical::QuantityOf<T, physical::dim_volume>;
|
||||
|
||||
template<typename T>
|
||||
concept Velocity = physical::QuantityOf<T, physical::dim_velocity>;
|
||||
|
||||
template<typename T>
|
||||
concept Acceleration = physical::QuantityOf<T, physical::dim_acceleration>;
|
||||
|
||||
template<typename T>
|
||||
concept Force = physical::QuantityOf<T, physical::dim_force>;
|
||||
|
||||
template<typename T>
|
||||
concept Energy = physical::QuantityOf<T, physical::dim_energy>;
|
||||
|
||||
template<typename T>
|
||||
concept Power = physical::QuantityOf<T, physical::dim_power>;
|
||||
|
||||
template<typename T>
|
||||
concept Voltage = physical::QuantityOf<T, physical::dim_voltage>;
|
||||
|
||||
template<typename T>
|
||||
concept ElectricCharge = physical::QuantityOf<T, physical::dim_electric_charge>;
|
||||
|
||||
template<typename T>
|
||||
concept Capacitance = physical::QuantityOf<T, physical::dim_capacitance>;
|
||||
|
||||
template<typename T>
|
||||
concept SurfaceTension = physical::QuantityOf<T, physical::dim_surface_tension>;
|
||||
|
||||
template<typename T>
|
||||
concept Pressure = physical::QuantityOf<T, physical::dim_pressure>;
|
||||
|
||||
} // namespace units
|
||||
|
||||
@@ -22,7 +22,8 @@
|
||||
|
||||
add_library(unit_tests_static
|
||||
# cgs_test.cpp
|
||||
# custom_unit_test.cpp
|
||||
custom_unit_test.cpp
|
||||
data_test.cpp
|
||||
dimension_op_test.cpp
|
||||
# fixed_string_test.cpp
|
||||
math_test.cpp
|
||||
|
||||
@@ -20,70 +20,37 @@
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#include <units/dimensions/voltage.h>
|
||||
#include <units/dimensions/frequency.h>
|
||||
#include <units/physical/si/voltage.h>
|
||||
#include <units/physical/si/frequency.h>
|
||||
#include <units/math.h>
|
||||
|
||||
/* ************** DERIVED DIMENSIONS THAT INCLUDE UNITS WITH SPECIAL NAMES **************** */
|
||||
|
||||
namespace {
|
||||
|
||||
struct base_dim_digital_information : units::base_dimension<"digital information", "b"> {};
|
||||
|
||||
struct digital_information : units::derived_dimension<digital_information, units::exp<base_dim_digital_information, 1>> {};
|
||||
|
||||
template<typename T>
|
||||
concept DigitalInformation = units::QuantityOf<T, digital_information>;
|
||||
|
||||
struct data_prefix : units::prefix_type {};
|
||||
|
||||
struct kibi : units::prefix<kibi, data_prefix, units::ratio< 1'024>, "Ki"> {};
|
||||
|
||||
struct bit : units::named_coherent_derived_unit<bit, digital_information, "b", data_prefix> {};
|
||||
struct kilobit : units::prefixed_derived_unit<kilobit, kibi, bit> {};
|
||||
|
||||
struct byte : units::named_scaled_derived_unit<byte, digital_information, "B", units::ratio<8>, data_prefix> {};
|
||||
struct kilobyte : units::prefixed_derived_unit<kilobyte, kibi, byte> {};
|
||||
|
||||
inline namespace literals {
|
||||
|
||||
constexpr auto operator""_b(unsigned long long l) { return units::quantity<bit, std::int64_t>(l); }
|
||||
constexpr auto operator""_Kib(unsigned long long l) { return units::quantity<kilobit, std::int64_t>(l); }
|
||||
constexpr auto operator""_B(unsigned long long l) { return units::quantity<byte, std::int64_t>(l); }
|
||||
constexpr auto operator""_KiB(unsigned long long l) { return units::quantity<kilobyte, std::int64_t>(l); }
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
static_assert(1_B == 8_b);
|
||||
static_assert(1024_b == 1_Kib);
|
||||
static_assert(1024_B == 1_KiB);
|
||||
static_assert(8 * 1024_b == 1_KiB);
|
||||
static_assert(8 * 1_Kib == 1_KiB);
|
||||
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
using namespace units;
|
||||
using namespace units::si;
|
||||
|
||||
// power spectral density
|
||||
struct power_spectral_density : derived_dimension<power_spectral_density, units::exp<voltage, 2>, units::exp<frequency, -1>> {};
|
||||
struct sq_volt_per_hertz : coherent_derived_unit<sq_volt_per_hertz, power_spectral_density> {};
|
||||
struct sq_volt_per_hertz : unit<sq_volt_per_hertz> {};
|
||||
struct dim_power_spectral_density : derived_dimension<dim_power_spectral_density, sq_volt_per_hertz, units::exp<dim_voltage, 2>, units::exp<dim_frequency, -1>> {};
|
||||
|
||||
template<Unit U, Scalar Rep = double>
|
||||
using power_spectral_density = quantity<dim_power_spectral_density, U, Rep>;
|
||||
|
||||
// amplitude spectral density
|
||||
struct amplitude_spectral_density : derived_dimension<amplitude_spectral_density, units::exp<voltage, 1>, units::exp<frequency, -1, 2>> {};
|
||||
struct volt_per_sqrt_hertz : coherent_derived_unit<volt_per_sqrt_hertz, amplitude_spectral_density> {};
|
||||
struct volt_per_sqrt_hertz : unit<volt_per_sqrt_hertz> {};
|
||||
struct dim_amplitude_spectral_density : derived_dimension<dim_amplitude_spectral_density, volt_per_sqrt_hertz, units::exp<dim_voltage, 1>, units::exp<dim_frequency, -1, 2>> {};
|
||||
|
||||
template<Unit U, Scalar Rep = double>
|
||||
using amplitude_spectral_density = quantity<dim_amplitude_spectral_density, U, Rep>;
|
||||
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
static_assert(std::is_same_v<dimension_sqrt<power_spectral_density>, amplitude_spectral_density>);
|
||||
static_assert(std::is_same_v<dimension_pow<amplitude_spectral_density, 2>, power_spectral_density>);
|
||||
static_assert(std::is_same_v<dimension_sqrt<dim_power_spectral_density>, dim_amplitude_spectral_density>);
|
||||
static_assert(std::is_same_v<dimension_pow<dim_amplitude_spectral_density, 2>, dim_power_spectral_density>);
|
||||
|
||||
static_assert(std::is_same_v<decltype(pow<2>(quantity<volt_per_sqrt_hertz>(4))), decltype(quantity<sq_volt_per_hertz>(16))>);
|
||||
static_assert(std::is_same_v<decltype(sqrt(quantity<sq_volt_per_hertz>(16))), decltype(quantity<volt_per_sqrt_hertz>(4))>);
|
||||
static_assert(std::is_same_v<decltype(pow<2>(amplitude_spectral_density<volt_per_sqrt_hertz>(4))), decltype(power_spectral_density<sq_volt_per_hertz>(16))>);
|
||||
static_assert(std::is_same_v<decltype(sqrt(power_spectral_density<sq_volt_per_hertz>(16))), decltype(amplitude_spectral_density<volt_per_sqrt_hertz>(4))>);
|
||||
|
||||
}
|
||||
|
||||
48
test/unit_test/static/data_test.cpp
Normal file
48
test/unit_test/static/data_test.cpp
Normal file
@@ -0,0 +1,48 @@
|
||||
// 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/data/bitrate.h>
|
||||
#include <units/data/information.h>
|
||||
|
||||
/* ************** DERIVED DIMENSIONS THAT INCLUDE UNITS WITH SPECIAL NAMES **************** */
|
||||
|
||||
namespace {
|
||||
|
||||
using namespace units::data;
|
||||
|
||||
// information
|
||||
|
||||
static_assert(1B == 8b);
|
||||
static_assert(1024b == 1Kib);
|
||||
static_assert(1024B == 1KiB);
|
||||
static_assert(8 * 1024b == 1KiB);
|
||||
static_assert(8 * 1Kib == 1KiB);
|
||||
|
||||
static_assert(1Kib == 1024b);
|
||||
static_assert(1Mib == 1024Kib);
|
||||
static_assert(1Gib == 1024Mib);
|
||||
static_assert(1Tib == 1024Gib);
|
||||
static_assert(1Pib == 1024Tib);
|
||||
|
||||
// bitrate
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user