gnc-rational.hpp

/********************************************************************
 * gnc-rational.hpp - A rational number library                     *
 * Copyright 2014 John Ralls <jralls@ceridwen.us>                   *
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
 *******************************************************************/
 
#ifndef __GNC_RATIONAL_HPP__
#define __GNC_RATIONAL_HPP__
 
#include "gnc-numeric.h"
#include "gnc-int128.hpp"
#include "gnc-rational-rounding.hpp"
 
class GncNumeric;
enum class RoundType;
enum class DenomType;
 
class GncRational
{
public:
    GncRational() : m_num(0), m_den(1) {}
    GncRational (GncInt128 num, GncInt128 den) noexcept
        : m_num(num), m_den(den) {}
    GncRational (gnc_numeric n) noexcept;
    GncRational(GncNumeric n) noexcept;
    GncRational(const GncRational& rhs) = default;
    GncRational(GncRational&& rhs) = default;
    GncRational& operator=(const GncRational& rhs) = default;
    GncRational& operator=(GncRational&& rhs) = default;
    ~GncRational() = default;
    bool valid() const noexcept;
    bool is_big() const noexcept;
    operator gnc_numeric() const noexcept;
    GncRational operator-() const noexcept;
    GncRational reduce() const;
    GncRational round_to_numeric() const;
    template <RoundType RT>
    GncRational convert (GncInt128 new_denom) const
    {
        auto params = prepare_conversion(new_denom);
        if (new_denom == GNC_DENOM_AUTO)
            new_denom = m_den;
        if (params.rem == 0)
            return GncRational(params.num, new_denom);
        return GncRational(round(params.num, params.den,
                                 params.rem, RT2T<RT>()), new_denom);
    }
 
    template <RoundType RT>
    GncRational convert_sigfigs(unsigned int figs) const
    {
        auto new_denom(sigfigs_denom(figs));
        auto params = prepare_conversion(new_denom);
        if (new_denom == 0) //It had better not, but just in case...
            new_denom = 1;
        if (params.rem == 0)
            return GncRational(params.num, new_denom);
        return GncRational(round(params.num, params.den,
                                params.rem, RT2T<RT>()), new_denom);
    }
 
    GncInt128 num() const noexcept { return m_num; }
    GncInt128 denom() const noexcept { return m_den; }
    void operator+=(GncRational b);
    void operator-=(GncRational b);
    void operator*=(GncRational b);
    void operator/=(GncRational b);
    GncRational inv() const noexcept;
    GncRational abs() const noexcept;
    int cmp(GncRational b);
    int cmp(GncInt128 b) { return cmp(GncRational(b, 1)); }
 
private:
    struct round_param
    {
        GncInt128 num;
        GncInt128 den;
        GncInt128 rem;
    };
    /* Calculates the denominator required to convert to figs sigfigs. Note that
     * it uses the same powten function that the GncNumeric version does because
     * 17 significant figures should be plenty.
     */
    GncInt128 sigfigs_denom(unsigned figs) const noexcept;
    /* Calculates a round_param struct to pass to a rounding function that will
     * finish computing a GncNumeric with the new denominator.
     */
    round_param prepare_conversion(GncInt128 new_denom) const;
    GncInt128 m_num;
    GncInt128 m_den;
};
 
inline int cmp(GncRational a, GncRational b) { return a.cmp(b); }
inline int cmp(GncRational a, GncInt128 b) { return a.cmp(b); }
inline int cmp(GncInt128 a, GncRational b) { return GncRational(a, 1).cmp(b); }
 
inline bool operator<(GncRational a, GncRational b) { return cmp(a, b) < 0; }
inline bool operator<(GncRational a, GncInt128 b) { return cmp(a, b) < 0; }
inline bool operator<(GncInt128 a, GncRational b) { return cmp(a, b) < 0; }
inline bool operator>(GncRational a, GncRational b) { return cmp(a, b) > 0; }
inline bool operator>(GncRational a, GncInt128 b) { return cmp(a, b) > 0; }
inline bool operator>(GncInt128 a, GncRational b) { return cmp(a, b) > 0; }
inline bool operator==(GncRational a, GncRational b) { return cmp(a, b) == 0; }
inline bool operator==(GncRational a, GncInt128 b) { return cmp(a, b) == 0; }
inline bool operator==(GncInt128 a, GncRational b) { return cmp(a, b) == 0; }
inline bool operator<=(GncRational a, GncRational b) { return cmp(a, b) <= 0; }
inline bool operator<=(GncRational a, GncInt128 b) { return cmp(a, b) <= 0; }
inline bool operator<=(GncInt128 a, GncRational b) { return cmp(a, b) <= 0; }
inline bool operator>=(GncRational a, GncRational b) { return cmp(a, b) >= 0; }
inline bool operator>=(GncRational a, GncInt128 b) { return cmp(a, b) >= 0; }
inline bool operator>=(GncInt128 a, GncRational b) { return cmp(a, b) >= 0; }
inline bool operator!=(GncRational a, GncRational b) { return cmp(a, b) != 0; }
inline bool operator!=(GncRational a, GncInt128 b) { return cmp(a, b) != 0; }
inline bool operator!=(GncInt128 a, GncRational b) { return cmp(a, b) != 0; }
GncRational operator+(GncRational a, GncRational b);
inline GncRational operator+(GncRational a, GncInt128 b)
{
    return a + GncRational(b, 1);
}
inline GncRational operator+(GncInt128 a, GncRational b)
{
    return GncRational(a, 1) + b;
}
GncRational operator-(GncRational a, GncRational b);
inline GncRational operator-(GncRational a, GncInt128 b)
{
    return a - GncRational(b, 1);
}
inline GncRational operator-(GncInt128 a, GncRational b)
{
    return GncRational(a, 1) - b;
}
GncRational operator*(GncRational a, GncRational b);
inline GncRational operator*(GncRational a, GncInt128 b)
{
    return a * GncRational(b, 1);
}
inline GncRational operator*(GncInt128 a, GncRational b)
{
    return GncRational(a, 1) * b;
}
GncRational operator/(GncRational a, GncRational b);
inline GncRational operator/(GncRational a, GncInt128 b)
{
    return a / GncRational(b, 1);
}
inline GncRational operator/(GncInt128 a, GncRational b)
{
    return GncRational(a, 1) / b;
}
 
inline std::ostream& operator<<(std::ostream& stream, const GncRational& val) noexcept
{
    stream << val.num() << "/" << val.denom();
    return stream;
}
#endif //__GNC_RATIONAL_HPP__