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"
**/
struct basis_unit2 {
struct basis_unit {
public:
constexpr basis_unit2() = default;
constexpr basis_unit2(dim native_dim, const scalefactor_ratio_type & scalefactor)
constexpr basis_unit() = default;
constexpr basis_unit(dim native_dim, const scalefactor_ratio_type & scalefactor)
: native_dim_{native_dim},
scalefactor_{scalefactor}
{}
@ -29,7 +29,7 @@ namespace xo {
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) **/
dim native_dim_ = dim::invalid;
@ -38,11 +38,11 @@ namespace xo {
};
namespace bu2 {
constexpr basis_unit2 nanogram = basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000000000));
constexpr basis_unit2 microgram = basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000000));
constexpr basis_unit2 milligram = basis_unit2(dim::mass, scalefactor_ratio_type(1, 1000));
constexpr basis_unit2 gram = basis_unit2(dim::mass, scalefactor_ratio_type(1, 1));
constexpr basis_unit2 kilogram = basis_unit2(dim::mass, scalefactor_ratio_type(1000, 1));
constexpr basis_unit nanogram = basis_unit(dim::mass, scalefactor_ratio_type(1, 1000000000));
constexpr basis_unit microgram = basis_unit(dim::mass, scalefactor_ratio_type(1, 1000000));
constexpr basis_unit milligram = basis_unit(dim::mass, scalefactor_ratio_type(1, 1000));
constexpr basis_unit gram = basis_unit(dim::mass, scalefactor_ratio_type(1, 1));
constexpr basis_unit kilogram = basis_unit(dim::mass, scalefactor_ratio_type(1000, 1));
}
namespace units {

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

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

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>
void bu_establish_abbrev_for() {
this->bu_establish_abbrev
(basis_unit2(BasisDim,
(basis_unit(BasisDim,
scalefactor_ratio_type(InnerScaleNum, InnerScaleDen)),
units::scaled_native_unit2_abbrev_v<BasisDim, InnerScaleNum, InnerScaleDen>);
}
/** @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) {
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/bpu2.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/reflect/Reflect.hpp"
//#include "xo/cxxutil/demangle.hpp"
@ -33,7 +33,7 @@ namespace xo {
using xo::qty::scalefactor_ratio_type;
using xo::qty::units::scaled_native_unit2_abbrev;
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::bpu2_abbrev_type;
using xo::qty::abbrev::bpu2_abbrev;
@ -88,65 +88,65 @@ namespace xo {
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
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"));
log && log("---------------------");