feedc0de/mp-units
1
0
Fork 0
forked from mpusz/mp-units
Code Pull Requests Activity

measurement example updated with a starship operator

Browse Source
This commit is contained in:
Mateusz Pusz
2019-12-17 09:12:11 +01:00
parent d5f7de8ecb
commit 1b2d27a64c
1 changed files with 82 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
example/measurement.cpp
View File

@@ -26,95 +26,105 @@
namespace { namespace {
// root sum of squares // root sum of squares
template<typename T> template<typename T>
T rss(const T& v1, const T& v2) T rss(const T& v1, const T& v2)
{
return std::sqrt(std::pow(v1, 2) + std::pow(v2, 2));
}
template<class T>
class measurement {
public:
using value_type = T;
measurement() = default;
constexpr /* explicit */ measurement(const value_type& val, const value_type& err = {}) :
// cannot be explicit as `magma` concept requires implicit conversions :-(
value_(val),
uncertainty_(std::abs(err))
{ {
return std::sqrt(std::pow(v1, 2) + std::pow(v2, 2));
} }
template<class T> constexpr const value_type& value() const { return value_; }
class measurement { constexpr const value_type& uncertainty() const { return uncertainty_; }
public:
using value_type = T;
measurement() = default; constexpr value_type relative_uncertainty() const { return uncertainty() / value(); }
constexpr value_type lower_bound() const { return value() - uncertainty(); }
constexpr value_type upper_bound() const { return value() + uncertainty(); }
constexpr /* explicit */ measurement(const value_type& val, const value_type& err = {}): // cannot be explicit as `magma` concept requires implicit conversions :-( [[nodiscard]] constexpr measurement operator-() const { return measurement(-value(), uncertainty()); }
value_(val), uncertainty_(std::abs(err))
{
}
constexpr const value_type& value() const { return value_; } [[nodiscard]] friend constexpr measurement operator+(const measurement& lhs, const measurement& rhs)
constexpr const value_type& uncertainty() const { return uncertainty_; } {
return measurement(lhs.value() + rhs.value(), rss(lhs.uncertainty(), rhs.uncertainty()));
}
constexpr value_type relative_uncertainty() const { return uncertainty() / value(); } [[nodiscard]] friend constexpr measurement operator-(const measurement& lhs, const measurement& rhs)
constexpr value_type lower_bound() const { return value() - uncertainty(); } {
constexpr value_type upper_bound() const { return value() + uncertainty(); } return measurement(lhs.value() - rhs.value(), rss(lhs.uncertainty(), rhs.uncertainty()));
}
[[nodiscard]] constexpr measurement operator-() const { return measurement(-value(), uncertainty()); } [[nodiscard]] friend constexpr measurement operator*(const measurement& lhs, const measurement& rhs)
{
const auto val = lhs.value() * rhs.value();
return measurement(val, val * rss(lhs.relative_uncertainty(), rhs.relative_uncertainty()));
}
[[nodiscard]] friend constexpr measurement operator+(const measurement& lhs, const measurement& rhs) [[nodiscard]] friend constexpr measurement operator/(const measurement& lhs, const measurement& rhs)
{ {
return measurement(lhs.value() + rhs.value(), rss(lhs.uncertainty(), rhs.uncertainty())); const auto val = lhs.value() / rhs.value();
} return measurement(val, val * rss(lhs.relative_uncertainty(), rhs.relative_uncertainty()));
}
[[nodiscard]] friend constexpr measurement operator-(const measurement& lhs, const measurement& rhs) #if __GNUC__ >= 10
{
return measurement(lhs.value() - rhs.value(), rss(lhs.uncertainty(), rhs.uncertainty()));
}
[[nodiscard]] friend constexpr measurement operator*(const measurement& lhs, const measurement& rhs) [[nodiscard]] friend constexpr auto operator<=>(const measurement& lhs, const measurement& rhs) = default;
{ [[nodiscard]] friend constexpr bool operator==(const measurement& lhs, const measurement& rhs) = default;
const auto val = lhs.value() * rhs.value();
return measurement(val, val * rss(lhs.relative_uncertainty(), rhs.relative_uncertainty()));
}
[[nodiscard]] friend constexpr measurement operator/(const measurement& lhs, const measurement& rhs) #else
{
const auto val = lhs.value() / rhs.value();
return measurement(val, val * rss(lhs.relative_uncertainty(), rhs.relative_uncertainty()));
}
[[nodiscard]] friend constexpr bool operator==(const measurement& lhs, const measurement& rhs) [[nodiscard]] friend constexpr bool operator==(const measurement& lhs, const measurement& rhs)
{ {
return lhs.value() == rhs.value() && lhs.uncertainty() == rhs.uncertainty(); return lhs.value() == rhs.value() && lhs.uncertainty() == rhs.uncertainty();
} }
[[nodiscard]] friend constexpr bool operator!=(const measurement& lhs, const measurement& rhs) [[nodiscard]] friend constexpr bool operator!=(const measurement& lhs, const measurement& rhs)
{ {
return !(lhs == rhs); return !(lhs == rhs);
} }
[[nodiscard]] friend constexpr bool operator<(const measurement& lhs, const measurement& rhs) [[nodiscard]] friend constexpr bool operator<(const measurement& lhs, const measurement& rhs)
{ {
return lhs.value() == rhs.value() ? lhs.uncertainty() < rhs.uncertainty() : lhs.value() < rhs.value(); return lhs.value() == rhs.value() ? lhs.uncertainty() < rhs.uncertainty() : lhs.value() < rhs.value();
} }
[[nodiscard]] friend constexpr bool operator>(const measurement& lhs, const measurement& rhs) [[nodiscard]] friend constexpr bool operator>(const measurement& lhs, const measurement& rhs) { return rhs < lhs; }
{
return rhs < lhs;
}
[[nodiscard]] friend constexpr bool operator<=(const measurement& lhs, const measurement& rhs) [[nodiscard]] friend constexpr bool operator<=(const measurement& lhs, const measurement& rhs)
{ {
return !(rhs < lhs); return !(rhs < lhs);
} }
[[nodiscard]] friend constexpr bool operator>=(const measurement& lhs, const measurement& rhs) [[nodiscard]] friend constexpr bool operator>=(const measurement& lhs, const measurement& rhs)
{ {
return !(lhs < rhs); return !(lhs < rhs);
} }
friend std::ostream& operator<<(std::ostream& os, const measurement& v) #endif
{
return os << v.value() << " ± " << v.uncertainty();
}
private: friend std::ostream& operator<<(std::ostream& os, const measurement& v)
value_type value_{}; {
value_type uncertainty_{}; return os << v.value() << " ± " << v.uncertainty();
}; }
private:
value_type value_{};
value_type uncertainty_{};
};
static_assert(units::Scalar<measurement<double>>);
} // namespace } // namespace
@@ -137,17 +147,15 @@ void example()
std::cout << "10 * " << length << " = " << 10 * length << '\n'; std::cout << "10 * " << length << " = " << 10 * length << '\n';
} }
} // namespace } // namespace
int main() int main()
{ {
try { try {
example(); example();
} } catch (const std::exception& ex) {
catch (const std::exception& ex) {
std::cerr << "Unhandled std exception caught: " << ex.what() << '\n'; std::cerr << "Unhandled std exception caught: " << ex.what() << '\n';
} } catch (...) {
catch (...) {
std::cerr << "Unhandled unknown exception caught\n"; std::cerr << "Unhandled unknown exception caught\n";
} }
} }