| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef LIB_AFFINE_RATIO_H_ |
| #define LIB_AFFINE_RATIO_H_ |
| |
| #include <stdint.h> |
| #include <limits> |
| #include <type_traits> |
| #include <zircon/assert.h> |
| |
| namespace affine { |
| |
| class Transform; // fwd decl for friendship |
| |
| class Ratio { |
| public: |
| enum class Exact { No, Yes }; |
| |
| // Used to indicate overflow/underflow of scaling operations. |
| static constexpr int64_t kOverflow = std::numeric_limits<int64_t>::max(); |
| static constexpr int64_t kUnderflow = std::numeric_limits<int64_t>::min(); |
| |
| // Reduces the ratio of N/D |
| // |
| // Defined only for uint32_t and uint64_t |
| template <typename T> |
| static void Reduce(T* numerator, T* denominator); |
| |
| // Produces the product two 32 bit ratios. If exact is true, ASSERTs on loss |
| // of precision. |
| static void Product(uint32_t a_numerator, |
| uint32_t a_denominator, |
| uint32_t b_numerator, |
| uint32_t b_denominator, |
| uint32_t* product_numerator, |
| uint32_t* product_denominator, |
| Exact exact = Exact::Yes); |
| |
| // Produces the product of a 32 bit ratio and the int64_t as an int64_t. Returns |
| // a saturated value (either kOverflow or kUnderflow) on overflow/underflow. |
| static int64_t Scale(int64_t value, uint32_t numerator, uint32_t denominator); |
| |
| // Returns the product of the ratios. If exact is true, ASSERTs on loss of |
| // precision. |
| static Ratio Product(Ratio a, Ratio b, Exact exact = Exact::Yes) { |
| uint32_t result_numerator; |
| uint32_t result_denominator; |
| Product(a.numerator(), a.denominator(), |
| b.numerator(), b.denominator(), |
| &result_numerator, &result_denominator, |
| exact); |
| return Ratio(result_numerator, result_denominator, NoReduce::Tag); |
| } |
| |
| Ratio() = default; |
| Ratio(uint32_t numerator, uint32_t denominator) |
| : numerator_(numerator), denominator_(denominator) { |
| Reduce(&numerator_, &denominator_); |
| } |
| |
| uint32_t numerator() const { return numerator_; } |
| uint32_t denominator() const { return denominator_; } |
| bool invertible() const { return numerator_ != 0; } |
| |
| Ratio Inverse() const { |
| ZX_ASSERT(invertible()); |
| return Ratio{denominator_, numerator_, NoReduce::Tag}; |
| } |
| |
| int64_t Scale(int64_t value) const { |
| return Scale(value, numerator_, denominator_); |
| } |
| |
| private: |
| friend class Transform; |
| enum class NoReduce { Tag }; |
| |
| Ratio(uint32_t numerator, uint32_t denominator, NoReduce) |
| : numerator_(numerator), denominator_(denominator) {} |
| |
| uint32_t numerator_ = 1; |
| uint32_t denominator_ = 1; |
| }; |
| |
| // Tests two ratios for equality. |
| inline bool operator==(Ratio a, Ratio b) { |
| return a.numerator() == b.numerator() && |
| a.denominator() == b.denominator(); |
| } |
| |
| // Tests two ratios for inequality. |
| inline bool operator!=(Ratio a, Ratio b) { return !(a == b); } |
| |
| // Returns the ratio of the two ratios. |
| inline Ratio operator/(Ratio a, Ratio b) { |
| return Ratio::Product(a, b.Inverse()); |
| } |
| |
| // Returns the product of the two ratios. |
| inline Ratio operator*(Ratio a, Ratio b) { |
| return Ratio::Product(a, b); |
| } |
| |
| // Returns the product of the rate and the int64_t. |
| inline int64_t operator*(Ratio a, int64_t b) { return a.Scale(b); } |
| |
| // Returns the product of the rate and the int64_t. |
| inline int64_t operator*(int64_t a, Ratio b) { return b.Scale(a); } |
| |
| // Returns the the int64_t divided by the rate. |
| inline int64_t operator/(int64_t a, Ratio b) { |
| return b.Inverse().Scale(a); |
| } |
| |
| } // namespace affine |
| |
| #endif // LIB_AFFINE_RATIO_H_ |