mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-03 12:24:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'go2sh-add_si_prefix_bit'

Browse Source
This commit is contained in:
Mateusz Pusz
2021-03-19 07:25:14 +01:00
parent ca7762177f 6c4dc95897
commit 3629173df2
4 changed files with 47 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/systems/data/include/units/data/bitrate.h
View File

@@ -38,6 +38,12 @@ struct gibibit_per_second : deduced_unit<gibibit_per_second, dim_bitrate, gibibi
struct tebibit_per_second : deduced_unit<tebibit_per_second, dim_bitrate, tebibit, isq::si::second> {};
struct pebibit_per_second : deduced_unit<pebibit_per_second, dim_bitrate, pebibit, isq::si::second> {};
struct kilobit_per_second : deduced_unit<kilobit_per_second, dim_bitrate, kilobit, isq::si::second> {};
struct megabit_per_second : deduced_unit<megabit_per_second, dim_bitrate, megabit, isq::si::second> {};
struct gigabit_per_second : deduced_unit<gigabit_per_second, dim_bitrate, gigabit, isq::si::second> {};
struct terabit_per_second : deduced_unit<terabit_per_second, dim_bitrate, terabit, isq::si::second> {};
struct petabit_per_second : deduced_unit<petabit_per_second, dim_bitrate, petabit, isq::si::second> {};
template<typename T>
concept Bitrate = QuantityOf<T, dim_bitrate>;
@@ -54,6 +60,12 @@ constexpr auto operator"" _q_Gib_per_s(unsigned long long l) { gsl_ExpectsAudit(
constexpr auto operator"" _q_Tib_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<tebibit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Pib_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<pebibit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_kb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<kilobit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Mb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<megabit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Gb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<gigabit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Tb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<terabit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Pb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<petabit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
} // namespace literals
namespace references {
@@ -65,6 +77,12 @@ inline constexpr auto Gib_per_s = reference<dim_bitrate, gibibit_per_second>{};
inline constexpr auto Tib_per_s = reference<dim_bitrate, tebibit_per_second>{};
inline constexpr auto Pib_per_s = reference<dim_bitrate, pebibit_per_second>{};
inline constexpr auto kb_per_s = reference<dim_bitrate, kilobit_per_second>{};
inline constexpr auto Mb_per_s = reference<dim_bitrate, megabit_per_second>{};
inline constexpr auto Gb_per_s = reference<dim_bitrate, gigabit_per_second>{};
inline constexpr auto Tb_per_s = reference<dim_bitrate, terabit_per_second>{};
inline constexpr auto Pb_per_s = reference<dim_bitrate, petabit_per_second>{};
} // namespace references
} // namespace units::data

22
src/systems/data/include/units/data/information.h
View File

@@ -24,6 +24,7 @@
#include <units/reference.h>
#include <units/base_dimension.h>
#include <units/isq/si/prefixes.h>
#include <units/data/prefixes.h>
#include <units/unit.h>
#include <units/quantity.h>
@@ -37,6 +38,13 @@ struct gibibit : prefixed_unit<gibibit, gibi, bit> {};
struct tebibit : prefixed_unit<tebibit, tebi, bit> {};
struct pebibit : prefixed_unit<pebibit, pebi, bit> {};
struct si_bit : alias_unit<bit, "b", isq::si::prefix> {};
struct kilobit : prefixed_unit<kilobit, isq::si::kilo, si_bit> {};
struct megabit : prefixed_unit<megabit, isq::si::mega, si_bit> {};
struct gigabit : prefixed_unit<gigabit, isq::si::giga, si_bit> {};
struct terabit : prefixed_unit<terabit, isq::si::tera, si_bit> {};
struct petabit : prefixed_unit<petabit, isq::si::peta, si_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> {};
@@ -62,6 +70,13 @@ constexpr auto operator"" _q_Gib(unsigned long long l) { gsl_ExpectsAudit(std::i
constexpr auto operator"" _q_Tib(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<tebibit, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Pib(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<pebibit, std::int64_t>(static_cast<std::int64_t>(l)); }
// bits (SI)
constexpr auto operator"" _q_kb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<kilobit, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Mb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<megabit, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Gb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<gigabit, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Tb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<terabit, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_Pb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<petabit, std::int64_t>(static_cast<std::int64_t>(l)); }
// bytes
constexpr auto operator"" _q_B(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<byte, std::int64_t>(static_cast<std::int64_t>(l)); }
constexpr auto operator"" _q_KiB(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<kibibyte, std::int64_t>(static_cast<std::int64_t>(l)); }
@@ -75,12 +90,19 @@ constexpr auto operator"" _q_PiB(unsigned long long l) { gsl_ExpectsAudit(std::i
namespace references {
inline constexpr auto b = reference<dim_information, bit>{};
inline constexpr auto Kib = reference<dim_information, kibibit>{};
inline constexpr auto Mib = reference<dim_information, mebibit>{};
inline constexpr auto Gib = reference<dim_information, gibibit>{};
inline constexpr auto Tib = reference<dim_information, tebibit>{};
inline constexpr auto Pib = reference<dim_information, pebibit>{};
inline constexpr auto kb = reference<dim_information, kilobit>{};
inline constexpr auto Mb = reference<dim_information, megabit>{};
inline constexpr auto Gb = reference<dim_information, gigabit>{};
inline constexpr auto Tb = reference<dim_information, terabit>{};
inline constexpr auto Pb = reference<dim_information, petabit>{};
inline constexpr auto B = reference<dim_information, byte>{};
inline constexpr auto KiB = reference<dim_information, kibibyte>{};
inline constexpr auto MiB = reference<dim_information, mebibyte>{};

4
test/unit_test/runtime/digital_info_test.cpp
View File

@@ -56,5 +56,9 @@ TEST_CASE("operator<< on a data quantity", "[text][ostream]")
stream << 8_q_Kib * 8_q_Kib / 2_q_b;
REQUIRE(stream.str() == "32 Mib");
}
SECTION("prefixed coherent unit (SI)") {
stream << 32_q_kb;
REQUIRE(stream.str() == "32 kb");
}
}
}

3
test/unit_test/static/data_test.cpp
View File

@@ -36,6 +36,9 @@ static_assert(1024_q_B == 1_q_KiB);
static_assert(8 * 1024_q_b == 1_q_KiB);
static_assert(8 * 1_q_Kib == 1_q_KiB);
static_assert(1_q_kb == 1000_q_b);
static_assert(2000_q_Mib == 2097152_q_kb);
static_assert(1_q_Kib == 1024_q_b);
static_assert(1_q_Mib == 1024_q_Kib);
static_assert(1_q_Gib == 1024_q_Mib);