Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <cstdint>
       8             : #include <functional>
       9             : #include <iosfwd>
      10             : 
      11             : #include "Utilities/ErrorHandling/Assert.hpp"
      12             : #include "Utilities/MakeWithValue.hpp"
      13             : #include "Utilities/Requires.hpp"
      14             : #include "Utilities/TypeTraits/IsInteger.hpp"
      15             : 
      16             : /// \cond
      17             : namespace PUP {
      18             : class er;
      19             : }  // namespace PUP
      20             : /// \endcond
      21             : 
      22             : /// \ingroup UtilitiesGroup
      23             : /// A rational number
      24             : ///
      25             : /// This serves as a faster replacement for
      26             : /// `boost::rational<std::int32_t>`.  As of Boost 1.65.0, arithmetic
      27             : /// operators average about twice as fast, and ordering operators are
      28             : /// about eight times as fast.
      29           1 : class Rational {
      30             :  public:
      31           0 :   Rational() = default;
      32           0 :   Rational(std::int32_t numerator, std::int32_t denominator);
      33             : 
      34             :   // Allow implicit conversion of integers to Rationals, but don't
      35             :   // allow doubles to implicitly convert to an integer and then to a
      36             :   // Rational.
      37             :   template <typename T, Requires<tt::is_integer_v<T>> = nullptr>
      38             :   // NOLINTNEXTLINE(google-explicit-constructor,readability-avoid-const-params-in-decls)
      39           0 :   Rational(const T integral_value) : Rational(integral_value, 1) {}
      40             : 
      41           0 :   std::int32_t numerator() const { return numerator_; }
      42           0 :   std::int32_t denominator() const { return denominator_; }
      43             : 
      44           0 :   double value() const;
      45             : 
      46           0 :   Rational inverse() const;
      47             : 
      48           0 :   Rational& operator+=(const Rational& other);
      49           0 :   Rational& operator-=(const Rational& other);
      50           0 :   Rational& operator*=(const Rational& other);
      51           0 :   Rational& operator/=(const Rational& other);
      52             : 
      53             :   // NOLINTNEXTLINE(google-runtime-references)
      54           0 :   void pup(PUP::er& p);
      55             : 
      56           0 :   friend Rational operator-(Rational r);
      57             : 
      58             :  private:
      59           0 :   std::int32_t numerator_{0};
      60           0 :   std::int32_t denominator_{1};
      61             : };
      62             : 
      63           0 : Rational operator+(const Rational& a, const Rational& b);
      64           0 : Rational operator-(const Rational& a, const Rational& b);
      65           0 : Rational operator*(const Rational& a, const Rational& b);
      66           0 : Rational operator/(const Rational& a, const Rational& b);
      67             : 
      68           0 : bool operator==(const Rational& a, const Rational& b);
      69           0 : bool operator!=(const Rational& a, const Rational& b);
      70           0 : bool operator<(const Rational& a, const Rational& b);
      71           0 : bool operator>(const Rational& a, const Rational& b);
      72           0 : bool operator<=(const Rational& a, const Rational& b);
      73           0 : bool operator>=(const Rational& a, const Rational& b);
      74             : 
      75           0 : Rational abs(const Rational& r);
      76             : 
      77           0 : std::ostream& operator<<(std::ostream& os, const Rational& r);
      78             : 
      79           0 : size_t hash_value(const Rational& r);
      80             : 
      81             : namespace std {
      82             : template <>
      83             : struct hash<Rational> {
      84             :   size_t operator()(const Rational& r) const;
      85             : };
      86             : }  // namespace std
      87             : 
      88             : namespace MakeWithValueImpls {
      89             : template <typename T>
      90           0 : struct MakeWithValueImpl<Rational, T> {
      91           0 :   static Rational apply(const T& /*input*/, double value) {
      92             :     ASSERT(static_cast<std::int32_t>(value) == value,
      93             :            "Only integer-valued Rationals can be created with MakeWithValue.");
      94             :     return Rational(static_cast<std::int32_t>(value));
      95             :   }
      96             : };
      97             : }  // namespace MakeWithValueImpls