mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-07-31 19:04:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor: all math functions refectored

Browse Source
This commit is contained in:
Mateusz Pusz
2023-06-14 15:57:59 +03:00
parent 3f88da4ebf
commit 3585e2a33c
1 changed files with 101 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
src/utility/include/mp-units/math.h
View File

@@ -24,6 +24,7 @@
#include <mp-units/bits/external/hacks.h> #include <mp-units/bits/external/hacks.h>
#include <mp-units/bits/value_cast.h> #include <mp-units/bits/value_cast.h>
#include <mp-units/customization_points.h>
#include <mp-units/quantity.h> #include <mp-units/quantity.h>
#include <mp-units/systems/angular/angular.h> #include <mp-units/systems/angular/angular.h>
#include <mp-units/systems/isq/space_and_time.h> #include <mp-units/systems/isq/space_and_time.h>
@@ -49,20 +50,20 @@ namespace mp_units {
* @param q Quantity being the base of the operation * @param q Quantity being the base of the operation
* @return Quantity The result of computation * @return Quantity The result of computation
*/ */
template<std::intmax_t Num, std::intmax_t Den = 1, Quantity Q> template<std::intmax_t Num, std::intmax_t Den = 1, auto R, typename Rep>
requires detail::non_zero<Den> requires detail::non_zero<Den> &&
[[nodiscard]] constexpr Quantity auto pow(const Q& q) noexcept requires { quantity_values<Rep>::one(); }
requires requires { pow(q.number(), 1.0); } || requires { std::pow(q.number(), 1.0); } [[nodiscard]] constexpr quantity<pow<Num, Den>(R), Rep> pow(const quantity<R, Rep>& q) noexcept
requires requires { pow(q.number(), 1.0); } || requires { std::pow(q.number(), 1.0); }
{ {
using rep = TYPENAME Q::rep;
if constexpr (Num == 0) { if constexpr (Num == 0) {
return quantity<pow<Num, Den>(Q::reference), rep>::one(); return quantity<pow<Num, Den>(R), Rep>::one();
} else if constexpr (ratio{Num, Den} == 1) { } else if constexpr (ratio{Num, Den} == 1) {
return q; return q;
} else { } else {
using std::pow; using std::pow;
return make_quantity<pow<Num, Den>(Q::reference)>( return make_quantity<pow<Num, Den>(R)>(
static_cast<rep>(pow(q.number(), static_cast<double>(Num) / static_cast<double>(Den)))); static_cast<Rep>(pow(q.number(), static_cast<double>(Num) / static_cast<double>(Den))));
} }
} }
@@ -74,13 +75,12 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Quantity Q>
* @param q Quantity being the base of the operation * @param q Quantity being the base of the operation
* @return Quantity The result of computation * @return Quantity The result of computation
*/ */
template<Quantity Q> template<auto R, typename Rep>
[[nodiscard]] constexpr Quantity auto sqrt(const Q& q) noexcept [[nodiscard]] constexpr quantity<sqrt(R), Rep> sqrt(const quantity<R, Rep>& q) noexcept
requires requires { sqrt(q.number()); } || requires { std::sqrt(q.number()); } requires requires { sqrt(q.number()); } || requires { std::sqrt(q.number()); }
{ {
using rep = TYPENAME Q::rep;
using std::sqrt; using std::sqrt;
return make_quantity<sqrt(Q::reference)>(static_cast<rep>(sqrt(q.number()))); return make_quantity<sqrt(R)>(static_cast<Rep>(sqrt(q.number())));
} }
/** /**
@@ -91,13 +91,12 @@ template<Quantity Q>
* @param q Quantity being the base of the operation * @param q Quantity being the base of the operation
* @return Quantity The result of computation * @return Quantity The result of computation
*/ */
template<Quantity Q> template<auto R, typename Rep>
[[nodiscard]] constexpr Quantity auto cbrt(const Q& q) noexcept [[nodiscard]] constexpr quantity<cbrt(R), Rep> cbrt(const quantity<R, Rep>& q) noexcept
requires requires { cbrt(q.number()); } || requires { std::cbrt(q.number()); } requires requires { cbrt(q.number()); } || requires { std::cbrt(q.number()); }
{ {
using rep = TYPENAME Q::rep;
using std::cbrt; using std::cbrt;
return make_quantity<cbrt(Q::reference)>(static_cast<rep>(cbrt(q.number()))); return make_quantity<cbrt(R)>(static_cast<Rep>(cbrt(q.number())));
} }
/** /**
@@ -108,12 +107,13 @@ template<Quantity Q>
* @param q Quantity being the base of the operation * @param q Quantity being the base of the operation
* @return Quantity The value of the same quantity type * @return Quantity The value of the same quantity type
*/ */
template<QuantityOf<dimension_one> Q> template<ReferenceOf<dimensionless> auto R, typename Rep>
[[nodiscard]] constexpr Q exp(const Q& q) [[nodiscard]] constexpr quantity<R, Rep> exp(const quantity<R, Rep>& q)
requires requires { exp(q.number()); } || requires { std::exp(q.number()); } requires requires { exp(q.number()); } || requires { std::exp(q.number()); }
{ {
using std::exp; using std::exp;
return value_cast<Q::unit>(make_quantity<dimensionless[one]>(exp(value_cast<one>(q).number()))); return value_cast<get_unit(R)>(
make_quantity<detail::clone_reference_with<one>(R)>(static_cast<Rep>(exp(value_cast<one>(q).number()))));
} }
/** /**
@@ -122,12 +122,12 @@ template<QuantityOf<dimension_one> Q>
* @param q Quantity being the base of the operation * @param q Quantity being the base of the operation
* @return Quantity The absolute value of a provided quantity * @return Quantity The absolute value of a provided quantity
*/ */
template<Quantity Q> template<auto R, typename Rep>
[[nodiscard]] constexpr Q abs(const Q& q) noexcept [[nodiscard]] constexpr quantity<R, Rep> abs(const quantity<R, Rep>& q) noexcept
requires requires { abs(q.number()); } || requires { std::abs(q.number()); } requires requires { abs(q.number()); } || requires { std::abs(q.number()); }
{ {
using std::abs; using std::abs;
return make_quantity<Q::reference>(abs(q.number())); return make_quantity<R>(static_cast<Rep>(abs(q.number())));
} }
/** /**
@@ -140,9 +140,9 @@ template<Quantity Q>
*/ */
template<Representation Rep, Reference R> template<Representation Rep, Reference R>
requires requires { std::numeric_limits<Rep>::epsilon(); } requires requires { std::numeric_limits<Rep>::epsilon(); }
[[nodiscard]] constexpr Quantity auto epsilon(R r) noexcept [[nodiscard]] constexpr quantity<R{}, Rep> epsilon(R r) noexcept
{ {
return make_quantity<r>(std::numeric_limits<Rep>::epsilon()); return make_quantity<r>(static_cast<Rep>(std::numeric_limits<Rep>::epsilon()));
} }
/** /**
@@ -152,12 +152,12 @@ template<Representation Rep, Reference R>
* @return Quantity The rounded quantity with unit type To * @return Quantity The rounded quantity with unit type To
*/ */
template<Unit auto To, auto R, typename Rep> template<Unit auto To, auto R, typename Rep>
[[nodiscard]] constexpr quantity<reference<get_quantity_spec(R), To>{}, Rep> floor(const quantity<R, Rep>& q) noexcept [[nodiscard]] constexpr quantity<detail::clone_reference_with<To>(R), Rep> floor(const quantity<R, Rep>& q) noexcept
requires((!treat_as_floating_point<Rep>) || requires { floor(q.number()); } || requires((!treat_as_floating_point<Rep>) || requires { floor(q.number()); } ||
requires { std::floor(q.number()); }) && requires { std::floor(q.number()); }) &&
(To == get_unit(R) || requires { (To == get_unit(R) || requires {
::mp_units::value_cast<To>(q); ::mp_units::value_cast<To>(q);
quantity<reference<get_quantity_spec(R), To>{}, Rep>::one(); quantity_values<Rep>::one();
}) })
{ {
const auto handle_signed_results = [&]<typename T>(const T& res) { const auto handle_signed_results = [&]<typename T>(const T& res) {
@@ -169,10 +169,10 @@ template<Unit auto To, auto R, typename Rep>
if constexpr (treat_as_floating_point<Rep>) { if constexpr (treat_as_floating_point<Rep>) {
using std::floor; using std::floor;
if constexpr (To == get_unit(R)) { if constexpr (To == get_unit(R)) {
return make_quantity<reference<get_quantity_spec(R), To>{}>(floor(q.number())); return make_quantity<detail::clone_reference_with<To>(R)>(static_cast<Rep>(floor(q.number())));
} else { } else {
return handle_signed_results( return handle_signed_results(make_quantity<detail::clone_reference_with<To>(q.reference)>(
make_quantity<reference<get_quantity_spec(R), To>{}>(floor(value_cast<To>(q).number()))); static_cast<Rep>(floor(value_cast<To>(q).number()))));
} }
} else { } else {
if constexpr (To == get_unit(R)) { if constexpr (To == get_unit(R)) {
@@ -190,11 +190,11 @@ template<Unit auto To, auto R, typename Rep>
* @return Quantity The rounded quantity with unit type To * @return Quantity The rounded quantity with unit type To
*/ */
template<Unit auto To, auto R, typename Rep> template<Unit auto To, auto R, typename Rep>
[[nodiscard]] constexpr quantity<reference<get_quantity_spec(R), To>{}, Rep> ceil(const quantity<R, Rep>& q) noexcept [[nodiscard]] constexpr quantity<detail::clone_reference_with<To>(R), Rep> ceil(const quantity<R, Rep>& q) noexcept
requires((!treat_as_floating_point<Rep>) || requires { ceil(q.number()); } || requires { std::ceil(q.number()); }) && requires((!treat_as_floating_point<Rep>) || requires { ceil(q.number()); } || requires { std::ceil(q.number()); }) &&
(To == get_unit(R) || requires { (To == get_unit(R) || requires {
::mp_units::value_cast<To>(q); ::mp_units::value_cast<To>(q);
quantity<reference<get_quantity_spec(R), To>{}, Rep>::one(); quantity_values<Rep>::one();
}) })
{ {
const auto handle_signed_results = [&]<typename T>(const T& res) { const auto handle_signed_results = [&]<typename T>(const T& res) {
@@ -206,10 +206,10 @@ template<Unit auto To, auto R, typename Rep>
if constexpr (treat_as_floating_point<Rep>) { if constexpr (treat_as_floating_point<Rep>) {
using std::ceil; using std::ceil;
if constexpr (To == get_unit(R)) { if constexpr (To == get_unit(R)) {
return make_quantity<reference<get_quantity_spec(R), To>{}>(ceil(q.number())); return make_quantity<detail::clone_reference_with<To>(q.reference)>(static_cast<Rep>(ceil(q.number())));
} else { } else {
return handle_signed_results( return handle_signed_results(make_quantity<detail::clone_reference_with<To>(q.reference)>(
make_quantity<reference<get_quantity_spec(R), To>{}>(ceil(value_cast<To>(q).number()))); static_cast<Rep>(ceil(value_cast<To>(q).number()))));
} }
} else { } else {
if constexpr (To == get_unit(R)) { if constexpr (To == get_unit(R)) {
@@ -229,18 +229,18 @@ template<Unit auto To, auto R, typename Rep>
* @return Quantity The rounded quantity with unit type To * @return Quantity The rounded quantity with unit type To
*/ */
template<Unit auto To, auto R, typename Rep> template<Unit auto To, auto R, typename Rep>
[[nodiscard]] constexpr quantity<reference<get_quantity_spec(R), To>{}, Rep> round(const quantity<R, Rep>& q) noexcept [[nodiscard]] constexpr quantity<detail::clone_reference_with<To>(R), Rep> round(const quantity<R, Rep>& q) noexcept
requires((!treat_as_floating_point<Rep>) || requires { round(q.number()); } || requires((!treat_as_floating_point<Rep>) || requires { round(q.number()); } ||
requires { std::round(q.number()); }) && requires { std::round(q.number()); }) &&
(To == get_unit(R) || requires { (To == get_unit(R) || requires {
::mp_units::floor<To>(q); ::mp_units::floor<To>(q);
quantity<reference<get_quantity_spec(R), To>{}, Rep>::one(); quantity_values<Rep>::one();
}) })
{ {
if constexpr (To == get_unit(R)) { if constexpr (To == get_unit(R)) {
if constexpr (treat_as_floating_point<Rep>) { if constexpr (treat_as_floating_point<Rep>) {
using std::round; using std::round;
return make_quantity<reference<get_quantity_spec(R), To>{}>(round(q.number())); return make_quantity<detail::clone_reference_with<To>(q.reference)>(static_cast<Rep>(round(q.number())));
} else { } else {
return value_cast<To>(q); return value_cast<To>(q);
} }
@@ -266,148 +266,148 @@ template<Unit auto To, auto R, typename Rep>
* @brief Computes the square root of the sum of the squares of x and y, * @brief Computes the square root of the sum of the squares of x and y,
* without undue overflow or underflow at intermediate stages of the computation * without undue overflow or underflow at intermediate stages of the computation
*/ */
template<Quantity Q1, Quantity Q2> template<auto R1, typename Rep1, auto R2, typename Rep2>
[[nodiscard]] constexpr QuantityOf<common_quantity_spec(Q1::quantity_spec, Q2::quantity_spec)> auto hypot( [[nodiscard]] constexpr QuantityOf<get_quantity_spec(common_reference(R1, R2))> auto hypot(
const Q1& x, const Q2& y) noexcept const quantity<R1, Rep1>& x, const quantity<R2, Rep2>& y) noexcept
requires requires { common_reference(Q1::reference, Q2::reference); } && requires requires { common_reference(R1, R2); } &&
( (
requires { hypot(x.number(), y.number()); } || requires { std::hypot(x.number(), y.number()); }) requires { hypot(x.number(), y.number()); } || requires { std::hypot(x.number(), y.number()); })
{ {
constexpr auto ref = common_reference(R1, R2);
constexpr auto unit = get_unit(ref);
using std::hypot; using std::hypot;
using type = quantity<common_reference(Q1::reference, Q2::reference), decltype(hypot(x.number(), y.number()))>; return make_quantity<ref>(hypot(x.number_in(unit), y.number_in(unit)));
return make_quantity<type::reference>(hypot(type{x}.number(), type{y}.number()));
} }
/** /**
* @brief Computes the square root of the sum of the squares of x, y, and z, * @brief Computes the square root of the sum of the squares of x, y, and z,
* without undue overflow or underflow at intermediate stages of the computation * without undue overflow or underflow at intermediate stages of the computation
*/ */
template<Quantity Q1, Quantity Q2, Quantity Q3> template<auto R1, typename Rep1, auto R2, typename Rep2, auto R3, typename Rep3>
[[nodiscard]] constexpr QuantityOf<common_quantity_spec(Q1::quantity_spec, Q2::quantity_spec, Q3::quantity_spec)> auto [[nodiscard]] constexpr QuantityOf<get_quantity_spec(common_reference(R1, R2, R3))> auto hypot(
hypot(const Q1& x, const Q2& y, const Q3& z) noexcept const quantity<R1, Rep1>& x, const quantity<R2, Rep2>& y, const quantity<R3, Rep3>& z) noexcept
requires requires { common_reference(Q1::reference, Q2::reference, Q3::reference); } && requires requires { common_reference(R1, R2, R3); } && (
( requires { hypot(x.number(), y.number(), z.number()); } ||
requires { hypot(x.number(), y.number(), z.number()); } || requires { std::hypot(x.number(), y.number(), z.number()); })
requires { std::hypot(x.number(), y.number(), z.number()); })
{ {
constexpr auto ref = common_reference(R1, R2);
constexpr auto unit = get_unit(ref);
using std::hypot; using std::hypot;
using type = quantity<common_reference(Q1::reference, Q2::reference, Q3::reference), return make_quantity<ref>(hypot(x.number_in(unit), y.number_in(unit), z.number_in(unit)));
decltype(hypot(x.number(), y.number(), z.number()))>;
return make_quantity<type::reference>(hypot(type{x}.number(), type{y}.number(), type{z}.number()));
} }
namespace isq { namespace isq {
template<QuantityOf<angular_measure> Q> template<ReferenceOf<angular_measure> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<dimensionless> auto sin(const Q& q) noexcept [[nodiscard]] inline quantity<one, Rep> sin(const quantity<R, Rep>& q) noexcept
requires requires { sin(q.number()); } || requires { std::sin(q.number()); } requires requires { sin(q.number()); } || requires { std::sin(q.number()); }
{ {
using std::sin; using std::sin;
return make_quantity<one>(sin(q[si::radian].number())); return make_quantity<one>(static_cast<Rep>(sin(q[si::radian].number())));
} }
template<QuantityOf<angular_measure> Q> template<ReferenceOf<angular_measure> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<dimensionless> auto cos(const Q& q) noexcept [[nodiscard]] inline quantity<one, Rep> cos(const quantity<R, Rep>& q) noexcept
requires requires { cos(q.number()); } || requires { std::cos(q.number()); } requires requires { cos(q.number()); } || requires { std::cos(q.number()); }
{ {
using std::cos; using std::cos;
return make_quantity<one>(cos(q[si::radian].number())); return make_quantity<one>(static_cast<Rep>(cos(q[si::radian].number())));
} }
template<QuantityOf<angular_measure> Q> template<ReferenceOf<angular_measure> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<dimensionless> auto tan(const Q& q) noexcept [[nodiscard]] inline quantity<one, Rep> tan(const quantity<R, Rep>& q) noexcept
requires requires { tan(q.number()); } || requires { std::tan(q.number()); } requires requires { tan(q.number()); } || requires { std::tan(q.number()); }
{ {
using std::tan; using std::tan;
return make_quantity<one>(tan(q[si::radian].number())); return make_quantity<one>(static_cast<Rep>(tan(q[si::radian].number())));
} }
template<QuantityOf<dimension_one> Q> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<angular_measure> auto asin(const Q& q) noexcept [[nodiscard]] inline quantity<si::radian, Rep> asin(const quantity<R, Rep>& q) noexcept
requires requires { asin(q.number()); } || requires { std::asin(q.number()); } requires requires { asin(q.number()); } || requires { std::asin(q.number()); }
{ {
using std::asin; using std::asin;
return make_quantity<angular_measure[si::radian]>(asin(value_cast<one>(q).number())); return make_quantity<si::radian>(static_cast<Rep>(asin(value_cast<one>(q).number())));
} }
template<QuantityOf<dimension_one> Q> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<angular_measure> auto acos(const Q& q) noexcept [[nodiscard]] inline quantity<si::radian, Rep> acos(const quantity<R, Rep>& q) noexcept
requires requires { acos(q.number()); } || requires { std::acos(q.number()); } requires requires { acos(q.number()); } || requires { std::acos(q.number()); }
{ {
using std::acos; using std::acos;
return make_quantity<angular_measure[si::radian]>(acos(value_cast<one>(q).number())); return make_quantity<si::radian>(static_cast<Rep>(acos(value_cast<one>(q).number())));
} }
template<QuantityOf<dimension_one> Q> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<angular_measure> auto atan(const Q& q) noexcept [[nodiscard]] inline quantity<si::radian, Rep> atan(const quantity<R, Rep>& q) noexcept
requires requires { atan(q.number()); } || requires { std::atan(q.number()); } requires requires { atan(q.number()); } || requires { std::atan(q.number()); }
{ {
using std::atan; using std::atan;
return make_quantity<angular_measure[si::radian]>(atan(value_cast<one>(q).number())); return make_quantity<si::radian>(static_cast<Rep>(atan(value_cast<one>(q).number())));
} }
} // namespace isq } // namespace isq
namespace angular { namespace angular {
template<QuantityOf<angle> Q> template<ReferenceOf<angle> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<dimensionless> auto sin(const Q& q) noexcept [[nodiscard]] inline quantity<one, Rep> sin(const quantity<R, Rep>& q) noexcept
requires requires { sin(q.number()); } || requires { std::sin(q.number()); } requires requires { sin(q.number()); } || requires { std::sin(q.number()); }
{ {
using std::sin; using std::sin;
return sin(q[radian].number()) * one; return make_quantity<one>(static_cast<Rep>(sin(q[radian].number())));
} }
template<QuantityOf<angle> Q> template<ReferenceOf<angle> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<dimensionless> auto cos(const Q& q) noexcept [[nodiscard]] inline quantity<one, Rep> cos(const quantity<R, Rep>& q) noexcept
requires requires { cos(q.number()); } || requires { std::cos(q.number()); } requires requires { cos(q.number()); } || requires { std::cos(q.number()); }
{ {
using std::cos; using std::cos;
return cos(q[radian].number()) * one; return make_quantity<one>(static_cast<Rep>(cos(q[radian].number())));
} }
template<QuantityOf<angle> Q> template<ReferenceOf<angle> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<dimensionless> auto tan(const Q& q) noexcept [[nodiscard]] inline quantity<one, Rep> tan(const quantity<R, Rep>& q) noexcept
requires requires { tan(q.number()); } || requires { std::tan(q.number()); } requires requires { tan(q.number()); } || requires { std::tan(q.number()); }
{ {
using std::tan; using std::tan;
return tan(q[radian].number()) * one; return make_quantity<one>(static_cast<Rep>(tan(q[radian].number())));
} }
template<QuantityOf<dimension_one> Q> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<angle> auto asin(const Q& q) noexcept [[nodiscard]] inline quantity<radian, Rep> asin(const quantity<R, Rep>& q) noexcept
requires requires { asin(q.number()); } || requires { std::asin(q.number()); } requires requires { asin(q.number()); } || requires { std::asin(q.number()); }
{ {
using std::asin; using std::asin;
return asin(value_cast<one>(q).number()) * angle[radian]; return make_quantity<radian>(static_cast<Rep>(asin(value_cast<one>(q).number())));
} }
template<QuantityOf<dimension_one> Q> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<angle> auto acos(const Q& q) noexcept [[nodiscard]] inline quantity<radian, Rep> acos(const quantity<R, Rep>& q) noexcept
requires requires { acos(q.number()); } || requires { std::acos(q.number()); } requires requires { acos(q.number()); } || requires { std::acos(q.number()); }
{ {
using std::acos; using std::acos;
return acos(value_cast<one>(q).number()) * angle[radian]; return make_quantity<radian>(static_cast<Rep>(acos(value_cast<one>(q).number())));
} }
template<QuantityOf<dimension_one> Q> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires treat_as_floating_point<typename Q::rep> requires treat_as_floating_point<Rep>
[[nodiscard]] inline QuantityOf<angle> auto atan(const Q& q) noexcept [[nodiscard]] inline quantity<radian, Rep> atan(const quantity<R, Rep>& q) noexcept
requires requires { atan(q.number()); } || requires { std::atan(q.number()); } requires requires { atan(q.number()); } || requires { std::atan(q.number()); }
{ {
using std::atan; using std::atan;
return atan(value_cast<one>(q).number()) * angle[radian]; return make_quantity<radian>(static_cast<Rep>(atan(value_cast<one>(q).number())));
} }
} // namespace angular } // namespace angular