combination with unsigned

[ka-ba]

Hi,
This is quite interesting stuff. I'm trying a bit to get my head around things (and that without C++20 experience).
First thing I experimented with is unsigned - since negative values don't make much sense for magnitudes (like e.g. distance, area, velocity). What would be the correct way to restrict values to be non-negative? My naive approach doesn't seem to work (I don't even get a warning with -Wsign-conversion enabled):

using Length = units::isq::si::length<units::isq::si::metre,unsigned int>;

int main(int,char*[]) {
    Length a=5*m,
    b=-17*m;
std::cout << -2 * kmph * (2 * h) << "\n";
std::cout << -1 * km / (1 * s) << "\n";
std::cout << -2 * m * (3 * m) << "\n";
std::cout << -2 * m * (-3 * m) << "\n";
std::cout << a << "\n";
std::cout << b << "\n";
return 0;
}

... would print:

-4 km
-1 × 10³ m/s
-6 m²
6 m²
5 m
4294967279 m

(Of course, I don't even have the faintest idea when I want to use floating point types.)

[JohelEGP]

What would be the correct way to restrict values to be non-negative?

See #353.

[ka-ba]

Thanks for your fast hint and sorry for the duplicate.

[ka-ba]

I finally discovered the chance to try to use units in a small private project of mine.
(In case, that you're interested, units is still in a branch: https://gitlab.com/ka-ba/vfrp/-/blob/strong-units/inc/vfrp-types.h )

With more or less straightforward types, I made some progress, but indeed again could need some hints on value-restricted types: the angle type(s) should be restricted to values from the first full circle (i.e. 0-pi*2 or 0-360). (NB: I'm aware that you also currently work on angles, but as I wanted to have a stable base, I decided to settle on your latest tag 0.7.0 .)

My current restricted base type for radians looks like this:

struct radian_base_t final {
    using value_type = double;
    value_type value{};
    constexpr radian_base_t() = default;
    constexpr /*explicit*/ radian_base_t(double const r_ad) : value(r_ad>std::numbers::pi*2. ? std::remainder(r_ad,std::numbers::pi*2.) : r_ad) {}
    auto operator<=>(radian_base_t const&) const = default;
    constexpr radian_base_t operator*(radian_base_t const rhs) const { return radian_base_t{value*rhs.value};} // to be removed
    constexpr radian_base_t operator*(double const rhs) const { return radian_base_t{value*rhs};}
    constexpr radian_base_t operator/(radian_base_t const rhs) const { return radian_base_t{value/rhs.value};} // to be removed
    constexpr radian_base_t operator/(double const rhs) const { return radian_base_t{value/rhs};}
    constexpr radian_base_t operator-(radian_base_t const rhs) const { return radian_base_t{value-rhs.value};}
    constexpr radian_base_t operator+(radian_base_t const rhs) const { return radian_base_t{value+rhs.value};}
    constexpr operator double() const { return value; }
    friend value_type std::sin(radian_base_t);
    friend value_type std::cos(radian_base_t);
};

And it's used like this:

using angle_t = units::angle<units::radian,radian_base_t>;

The base type for degrees (0-360) looks quite similar and I tried to get the most accurate ratio between the two:

constexpr auto MULTIPLIER = std::numeric_limits<std::intmax_t>::max()/200;
constexpr auto MULTIPLEPI = static_cast<std::intmax_t>(std::numbers::pi_v<long double>*MULTIPLIER);
constexpr auto MULTIPLE180 = MULTIPLIER*180;
namespace units {
struct deg : named_scaled_unit<deg, "deg", no_prefix, ratio(MULTIPLEPI, MULTIPLE180), radian> {};
}

using deg_t = units::angle<units::deg,degree_base_t>;

The problem I wasn't able to find a solution to in the last days begins when I try to convert between the two quantitys: auto const deg = units::quantity_cast<deg_t>(radi); (with radi being of angle_t) - this doesn't compile because some concepts are not met. Defining the implicit conversion operator to double on both base types got me one step further, because it acts as common_type for them. But common_type_with_<radian_base_t, degree_base_t> still evaluates to false.

Currently I don't understand the problem, so cannot see a way forward. Being able to convert between the two units would be handy, because it would be the clean way to generate an angle value in degrees to use in the gui for display and manipulation while internally calculating with the value in radians.

[JohelEGP]

I'd recommend opening an issue, with reduced code that shows the problem, and the actual compiler error. Ideally, with a link to Compiler Explorer demonstrating the issue.