roland/xo-alloc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-unit: refactor: basis_unit2 -> basis_unit

Browse source
This commit is contained in:
Roland Conybeare 2024-04-22 20:30:50 -04:00
commit ba38f4e03b
4 changed files with 47 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

18
include/xo/unit/basis_unit2.hpp → include/xo/unit/basis_unit.hpp
View file

@ -13,10 +13,10 @@ namespace xo {
* *
* For example "3600 minutes" or "1e-6 grams" * For example "3600 minutes" or "1e-6 grams"
**/ **/
struct basis_unit2 { struct basis_unit {
public: public:
constexpr basis_unit2() = default; constexpr basis_unit() = default;
constexpr basis_unit2(dim native_dim, const scalefactor_ratio_type & scalefactor) constexpr basis_unit(dim native_dim, const scalefactor_ratio_type & scalefactor)
: native_dim_{native_dim}, : native_dim_{native_dim},
scalefactor_{scalefactor} scalefactor_{scalefactor}
{} {}
@ -29,7 +29,7 @@ namespace xo {
scalefactor_); scalefactor_);
} }
constexpr basis_unit2 & operator=(const basis_unit2 & x) = default; constexpr basis_unit & operator=(const basis_unit & x) = default;
/** @brief identifies a native unit, e.g. time (in seconds) **/ /** @brief identifies a native unit, e.g. time (in seconds) **/
dim native_dim_ = dim::invalid; dim native_dim_ = dim::invalid;
@ -38,11 +38,11 @@ namespace xo {
}; };
namespace bu2 { namespace bu2 {
constexpr basis_unit2 nanogram = basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000000000)); constexpr basis_unit nanogram = basis_unit(dim::mass, scalefactor_ratio_type(1, 1000000000));
constexpr basis_unit2 microgram = basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000000)); constexpr basis_unit microgram = basis_unit(dim::mass, scalefactor_ratio_type(1, 1000000));
constexpr basis_unit2 milligram = basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000)); constexpr basis_unit milligram = basis_unit(dim::mass, scalefactor_ratio_type(1, 1000));
constexpr basis_unit2 gram = basis_unit2(dim::mass, scalefactor_ratio_type(1, 1)); constexpr basis_unit gram = basis_unit(dim::mass, scalefactor_ratio_type(1, 1));
constexpr basis_unit2 kilogram = basis_unit2(dim::mass, scalefactor_ratio_type(1000, 1)); constexpr basis_unit kilogram = basis_unit(dim::mass, scalefactor_ratio_type(1000, 1));
} }
namespace units { namespace units {

14
include/xo/unit/bpu2.hpp
View file

@ -6,7 +6,7 @@
#pragma once #pragma once
#include "xo/indentlog/print/tag.hpp" #include "xo/indentlog/print/tag.hpp"
#include "basis_unit2.hpp" #include "basis_unit.hpp"
#include "dim_iostream.hpp" #include "dim_iostream.hpp"
namespace xo { namespace xo {
@ -58,25 +58,25 @@ namespace xo {
* native_bpu<universal::time, ratio<1>, ratio<-1,2>> represents unit of 1/sqrt(t) * native_bpu<universal::time, ratio<1>, ratio<-1,2>> represents unit of 1/sqrt(t)
**/ **/
template<typename Int> template<typename Int>
struct bpu2 : basis_unit2 { struct bpu2 : basis_unit {
public: public:
using ratio_int_type = Int; using ratio_int_type = Int;
public: public:
constexpr bpu2() = default; constexpr bpu2() = default;
constexpr bpu2(const basis_unit2 & bu, constexpr bpu2(const basis_unit & bu,
const power_ratio_type & power) const power_ratio_type & power)
: basis_unit2{bu}, : basis_unit{bu},
power_{power} power_{power}
{} {}
constexpr bpu2(dim native_dim, constexpr bpu2(dim native_dim,
const scalefactor_ratio_type & scalefactor, const scalefactor_ratio_type & scalefactor,
const power_ratio_type & power) const power_ratio_type & power)
: basis_unit2(native_dim, scalefactor), : basis_unit(native_dim, scalefactor),
power_{power} power_{power}
{} {}
static constexpr bpu2<Int> unit_power(const basis_unit2 & bu) { static constexpr bpu2<Int> unit_power(const basis_unit & bu) {
return bpu2<Int>(bu, power_ratio_type(1,1)); return bpu2<Int>(bu, power_ratio_type(1,1));
} }
@ -107,7 +107,7 @@ namespace xo {
}; };
template <typename Int> template <typename Int>
constexpr auto make_unit_power(const basis_unit2 & bu) { constexpr auto make_unit_power(const basis_unit & bu) {
return bpu2<Int>::unit_power(bu); return bpu2<Int>::unit_power(bu);
} }

4
include/xo/unit/bpu_store.hpp
View file

@ -77,14 +77,14 @@ namespace xo {
template <dim BasisDim, std::int64_t InnerScaleNum, std::int64_t InnerScaleDen> template <dim BasisDim, std::int64_t InnerScaleNum, std::int64_t InnerScaleDen>
void bu_establish_abbrev_for() { void bu_establish_abbrev_for() {
this->bu_establish_abbrev this->bu_establish_abbrev
(basis_unit2(BasisDim, (basis_unit(BasisDim,
scalefactor_ratio_type(InnerScaleNum, InnerScaleDen)), scalefactor_ratio_type(InnerScaleNum, InnerScaleDen)),
units::scaled_native_unit2_abbrev_v<BasisDim, InnerScaleNum, InnerScaleDen>); units::scaled_native_unit2_abbrev_v<BasisDim, InnerScaleNum, InnerScaleDen>);
} }
/** @brief establish abbreviation @p abbrev for basis unit @p bu /** @brief establish abbreviation @p abbrev for basis unit @p bu
**/ **/
void bu_establish_abbrev(const basis_unit2 & bu, void bu_establish_abbrev(const basis_unit & bu,
const basis_unit2_abbrev_type & abbrev) { const basis_unit2_abbrev_type & abbrev) {
auto & bu_abbrev_v = bu_abbrev_vv_[static_cast<std::size_t>(bu.native_dim())]; auto & bu_abbrev_v = bu_abbrev_vv_[static_cast<std::size_t>(bu.native_dim())];

58
utest/unit.test.cpp
View file

@ -9,7 +9,7 @@
#include "xo/unit/bpu_store.hpp" #include "xo/unit/bpu_store.hpp"
#include "xo/unit/bpu2.hpp" #include "xo/unit/bpu2.hpp"
#include "xo/unit/bpu2_iostream.hpp" #include "xo/unit/bpu2_iostream.hpp"
#include "xo/unit/basis_unit2.hpp" #include "xo/unit/basis_unit.hpp"
#include "xo/unit/native_unit.hpp" #include "xo/unit/native_unit.hpp"
#include "xo/reflect/Reflect.hpp" #include "xo/reflect/Reflect.hpp"
//#include "xo/cxxutil/demangle.hpp" //#include "xo/cxxutil/demangle.hpp"
@ -33,7 +33,7 @@ namespace xo {
using xo::qty::scalefactor_ratio_type; using xo::qty::scalefactor_ratio_type;
using xo::qty::units::scaled_native_unit2_abbrev; using xo::qty::units::scaled_native_unit2_abbrev;
using xo::qty::units::scaled_native_unit2_abbrev_v; using xo::qty::units::scaled_native_unit2_abbrev_v;
using xo::qty::basis_unit2; using xo::qty::basis_unit;
using xo::qty::abbrev::basis_unit2_abbrev;; using xo::qty::abbrev::basis_unit2_abbrev;;
using xo::qty::bpu2_abbrev_type; using xo::qty::bpu2_abbrev_type;
using xo::qty::abbrev::bpu2_abbrev; using xo::qty::abbrev::bpu2_abbrev;
@ -88,65 +88,65 @@ namespace xo {
log && log("---------------------"); log && log("---------------------");
static_assert(basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000000000)).abbrev() static_assert(basis_unit(dim::mass, scalefactor_ratio_type(1, 1000000000)).abbrev()
== basis_unit2_abbrev_type::from_chars("ng")); == basis_unit2_abbrev_type::from_chars("ng"));
static_assert(basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000000)).abbrev() static_assert(basis_unit(dim::mass, scalefactor_ratio_type(1, 1000000)).abbrev()
== basis_unit2_abbrev_type::from_chars("ug")); == basis_unit2_abbrev_type::from_chars("ug"));
static_assert(basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000)).abbrev() static_assert(basis_unit(dim::mass, scalefactor_ratio_type(1, 1000)).abbrev()
== basis_unit2_abbrev_type::from_chars("mg")); == basis_unit2_abbrev_type::from_chars("mg"));
static_assert(basis_unit2(dim::mass, scalefactor_ratio_type(1, 1)).abbrev() static_assert(basis_unit(dim::mass, scalefactor_ratio_type(1, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("g")); == basis_unit2_abbrev_type::from_chars("g"));
static_assert(basis_unit2(dim::mass, scalefactor_ratio_type(1000, 1)).abbrev() static_assert(basis_unit(dim::mass, scalefactor_ratio_type(1000, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("kg")); == basis_unit2_abbrev_type::from_chars("kg"));
static_assert(basis_unit2(dim::mass, scalefactor_ratio_type(1000000, 1)).abbrev() static_assert(basis_unit(dim::mass, scalefactor_ratio_type(1000000, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("t")); == basis_unit2_abbrev_type::from_chars("t"));
static_assert(basis_unit2(dim::mass, scalefactor_ratio_type(1000000000, 1)).abbrev() static_assert(basis_unit(dim::mass, scalefactor_ratio_type(1000000000, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("kt")); == basis_unit2_abbrev_type::from_chars("kt"));
log && log(xtag("distance", basis_unit2_abbrev(dim::distance, scalefactor_ratio_type(1, 1)))); log && log(xtag("distance", basis_unit2_abbrev(dim::distance, scalefactor_ratio_type(1, 1))));
static_assert(basis_unit2(dim::distance, scalefactor_ratio_type(1, 1000000000)).abbrev() static_assert(basis_unit(dim::distance, scalefactor_ratio_type(1, 1000000000)).abbrev()
== basis_unit2_abbrev_type::from_chars("nm")); == basis_unit2_abbrev_type::from_chars("nm"));
static_assert(basis_unit2(dim::distance, scalefactor_ratio_type(1, 1000000)).abbrev() static_assert(basis_unit(dim::distance, scalefactor_ratio_type(1, 1000000)).abbrev()
== basis_unit2_abbrev_type::from_chars("um")); == basis_unit2_abbrev_type::from_chars("um"));
static_assert(basis_unit2(dim::distance, scalefactor_ratio_type(1, 1000)).abbrev() static_assert(basis_unit(dim::distance, scalefactor_ratio_type(1, 1000)).abbrev()
== basis_unit2_abbrev_type::from_chars("mm")); == basis_unit2_abbrev_type::from_chars("mm"));
static_assert(basis_unit2(dim::distance, scalefactor_ratio_type(1, 1)).abbrev() static_assert(basis_unit(dim::distance, scalefactor_ratio_type(1, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("m")); == basis_unit2_abbrev_type::from_chars("m"));
static_assert(basis_unit2(dim::distance, scalefactor_ratio_type(1000, 1)).abbrev() static_assert(basis_unit(dim::distance, scalefactor_ratio_type(1000, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("km")); == basis_unit2_abbrev_type::from_chars("km"));
static_assert(basis_unit2(dim::distance, scalefactor_ratio_type(1000000, 1)).abbrev() static_assert(basis_unit(dim::distance, scalefactor_ratio_type(1000000, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("Mm")); == basis_unit2_abbrev_type::from_chars("Mm"));
static_assert(basis_unit2(dim::distance, scalefactor_ratio_type(1000000000, 1)).abbrev() static_assert(basis_unit(dim::distance, scalefactor_ratio_type(1000000000, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("Gm")); == basis_unit2_abbrev_type::from_chars("Gm"));
log && log(xtag("time", basis_unit2_abbrev(dim::time, scalefactor_ratio_type(1, 1)))); log && log(xtag("time", basis_unit2_abbrev(dim::time, scalefactor_ratio_type(1, 1))));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(1, 1000000000)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(1, 1000000000)).abbrev()
== basis_unit2_abbrev_type::from_chars("ns")); == basis_unit2_abbrev_type::from_chars("ns"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(1, 1000000)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(1, 1000000)).abbrev()
== basis_unit2_abbrev_type::from_chars("us")); == basis_unit2_abbrev_type::from_chars("us"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(1, 1000000)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(1, 1000000)).abbrev()
== basis_unit2_abbrev_type::from_chars("us")); == basis_unit2_abbrev_type::from_chars("us"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(1, 1000)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(1, 1000)).abbrev()
== basis_unit2_abbrev_type::from_chars("ms")); == basis_unit2_abbrev_type::from_chars("ms"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(1, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(1, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("s")); == basis_unit2_abbrev_type::from_chars("s"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(60, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(60, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("min")); == basis_unit2_abbrev_type::from_chars("min"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(3600, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(3600, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("hr")); == basis_unit2_abbrev_type::from_chars("hr"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(24*3600, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(24*3600, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("dy")); == basis_unit2_abbrev_type::from_chars("dy"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(7*24*3600, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(7*24*3600, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("wk")); == basis_unit2_abbrev_type::from_chars("wk"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(30*24*3600, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(30*24*3600, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("mo")); == basis_unit2_abbrev_type::from_chars("mo"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(250*24*3600, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(250*24*3600, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("yr250")); == basis_unit2_abbrev_type::from_chars("yr250"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(360*24*3600, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(360*24*3600, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("yr360")); == basis_unit2_abbrev_type::from_chars("yr360"));
static_assert(basis_unit2(dim::time, scalefactor_ratio_type(365*24*3600, 1)).abbrev() static_assert(basis_unit(dim::time, scalefactor_ratio_type(365*24*3600, 1)).abbrev()
== basis_unit2_abbrev_type::from_chars("yr365")); == basis_unit2_abbrev_type::from_chars("yr365"));
log && log("---------------------"); log && log("---------------------");