fraction.h

Go to the documentation of this file.

/*
 * Copyright 2023 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <ostream>
#include <type_traits>  // IWYU pragma: keep
 
#include <fmt/base.h>
#include <fmt/ostream.h>  // IWYU pragma: keep
 
#include "num_collect/base/concepts/integral.h"
#include "num_collect/base/exception.h"
#include "num_collect/base/precondition.h"
#include "num_collect/logging/logging_macros.h"
#include "num_collect/util/greatest_common_divisor.h"
#include "num_collect/util/multiply_safely.h"
 
namespace num_collect::numbers {
 
template <base::concepts::integral IntegerType>
class fraction {
public:
    using integer_type = IntegerType;
 
    constexpr fraction(integer_type numerator, integer_type denominator)
        : numerator_(numerator), denominator_(denominator) {
        NUM_COLLECT_PRECONDITION(denominator_ != static_cast<integer_type>(0),
            "The denominator of a fraction must not be zero.");
        normalize();
    }
 
    constexpr fraction(  // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
        integer_type integer) noexcept
        : numerator_(integer), denominator_(static_cast<integer_type>(1)) {}
 
    constexpr fraction() noexcept : fraction(static_cast<integer_type>(0)) {}
 
    [[nodiscard]] constexpr auto numerator() const noexcept -> integer_type {
        return numerator_;
    }
 
    [[nodiscard]] constexpr auto denominator() const noexcept -> integer_type {
        return denominator_;
    }
 
    constexpr auto operator+=(const fraction& right) -> fraction& {
        add(right);
        return *this;
    }
 
    constexpr auto add(const fraction& right) -> fraction& {
        if (denominator_ == right.denominator_) {
            // TODO: Add safely.
            numerator_ += right.numerator_;
        } else {
            const integer_type common_divisor =
                util::greatest_common_divisor(denominator_, right.denominator_);
            const integer_type right_coeff = denominator_ / common_divisor;
            const integer_type my_coeff = right.denominator_ / common_divisor;
 
            denominator_ = util::multiply_safely(denominator_, my_coeff);
 
            // TODO: Add safely.
            numerator_ = util::multiply_safely(numerator_, my_coeff) +
                util::multiply_safely(right.numerator_, right_coeff);
        }
        normalize();
        return *this;
    }
 
    constexpr auto operator-=(const fraction& right) -> fraction& {
        subtract(right);
        return *this;
    }
 
    constexpr auto subtract(const fraction& right) -> fraction& {
        if (denominator_ == right.denominator_) {
            // TODO: Subtract safely.
            numerator_ -= right.numerator_;
        } else {
            const integer_type common_divisor =
                util::greatest_common_divisor(denominator_, right.denominator_);
            const integer_type right_coeff = denominator_ / common_divisor;
            const integer_type my_coeff = right.denominator_ / common_divisor;
 
            denominator_ = util::multiply_safely(denominator_, my_coeff);
 
            // TODO: Subtract safely.
            numerator_ = util::multiply_safely(numerator_, my_coeff) -
                util::multiply_safely(right.numerator_, right_coeff);
        }
        normalize();
        return *this;
    }
 
    constexpr auto operator*=(const fraction& right) -> fraction& {
        multiply(right);
        return *this;
    }
 
    constexpr auto multiply(const fraction& right) -> fraction& {
        numerator_ = util::multiply_safely(numerator_, right.numerator_);
        denominator_ = util::multiply_safely(denominator_, right.denominator_);
        normalize();
        return *this;
    }
 
    constexpr auto operator/=(const fraction& right) -> fraction& {
        divide_by(right);
        return *this;
    }
 
    constexpr auto divide_by(const fraction& right) -> fraction& {
        multiply(right.inverse());
        return *this;
    }
 
    [[nodiscard]] constexpr auto inverse() const -> fraction {
        return fraction<integer_type>(denominator_, numerator_);
    }
 
    constexpr auto operator==(const fraction& right) const noexcept -> bool {
        // This fraction is always normalized, so simple comparison is enough.
        return denominator_ == right.denominator_ &&
            numerator_ == right.numerator_;
    }
 
    constexpr auto operator!=(const fraction& right) const noexcept -> bool {
        return !operator==(right);
    }
 
private:
    constexpr void normalize() {
        if constexpr (std::is_signed_v<integer_type>) {
            if (denominator_ < static_cast<integer_type>(0)) {
                numerator_ = -numerator_;
                denominator_ = -denominator_;
            }
        }
 
        if (numerator_ == static_cast<integer_type>(0)) {
            denominator_ = static_cast<integer_type>(1);
            return;
        }
 
        const auto common_divisor =
            util::greatest_common_divisor(int_abs(numerator_), denominator_);
        numerator_ /= common_divisor;
        denominator_ /= common_divisor;
    }
 
    static constexpr auto int_abs(integer_type x) noexcept -> integer_type {
        // TODO: move to utility or base.
        if constexpr (std::is_unsigned_v<integer_type>) {
            return x;
        } else {
            if (x < static_cast<integer_type>(0)) {
                return -x;
            }
            return x;
        }
    }
 
    integer_type numerator_;
 
    integer_type denominator_;
};
 
template <num_collect::base::concepts::integral Integer>
constexpr auto operator+(const fraction<Integer>& left,
    const fraction<Integer>& right) -> fraction<Integer> {
    return fraction<Integer>(left) += right;
}
 
template <num_collect::base::concepts::integral Integer>
constexpr auto operator-(const fraction<Integer>& left,
    const fraction<Integer>& right) -> fraction<Integer> {
    return fraction<Integer>(left) -= right;
}
 
template <num_collect::base::concepts::integral Integer>
constexpr auto operator*(const fraction<Integer>& left,
    const fraction<Integer>& right) -> fraction<Integer> {
    return fraction<Integer>(left) *= right;
}
 
template <num_collect::base::concepts::integral Integer>
constexpr auto operator/(const fraction<Integer>& left,
    const fraction<Integer>& right) -> fraction<Integer> {
    return fraction<Integer>(left) /= right;
}
 
}  // namespace num_collect::numbers
 
namespace fmt {
 
template <num_collect::base::concepts::integral Integer>
struct formatter<num_collect::numbers::fraction<Integer>> {
public:
    constexpr auto parse(format_parse_context& context)  // NOLINT
        -> decltype(context.begin()) {
        return context.end();
    }
 
    auto format(num_collect::numbers::fraction<Integer> val,
        format_context& context) const {
        return fmt::format_to(
            context.out(), "{} / {}", val.numerator(), val.denominator());
    }
};
 
}  // namespace fmt
 
namespace num_collect::numbers {
 
template <num_collect::base::concepts::integral Integer>
inline auto operator<<(std::ostream& stream, const fraction<Integer>& val)
    -> std::ostream& {
    fmt::print(stream, "{}", val);
    return stream;
}
 
}  // namespace num_collect::numbers