gnc-numeric.hpp

/********************************************************************
 * gnc-numeric.hpp - A rational number library for int64            *
 * Copyright 2017 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_NUMERIC_HPP__
#define __GNC_NUMERIC_HPP__

#include <string>
#include <iostream>
#include <locale>
#include <typeinfo> // For std::bad_cast exception
#include <cstdint>
#include "gnc-rational-rounding.hpp"

class GncRational;

class GncNumeric
{
public:
    GncNumeric() : m_num (0), m_den(1) {}
    GncNumeric(int64_t num, int64_t denom) :
        m_num(num), m_den(denom) {
        if (denom == 0)
            throw std::invalid_argument("Attempt to construct a GncNumeric with a 0 denominator.");
    }
    GncNumeric(GncRational rr);
    GncNumeric(gnc_numeric in) : m_num(in.num), m_den(in.denom)
    {
        if (in.denom == 0)
            throw std::invalid_argument("Attempt to construct a GncNumeric with a 0 denominator.");
        /* gnc_numeric has a dumb convention that a negative denominator means
         * to multiply the numerator by the denominator instead of dividing.
         */
        if (in.denom < 0)
        {
            m_num *= -in.denom;
            m_den = 1;
        }
    }
    GncNumeric(double d);

    GncNumeric(const std::string& str, bool autoround=false);
    GncNumeric(const GncNumeric& rhs) = default;
    GncNumeric(GncNumeric&& rhs) = default;
    GncNumeric& operator=(const GncNumeric& rhs) = default;
    GncNumeric& operator=(GncNumeric&& rhs) = default;
    ~GncNumeric() = default;
    operator gnc_numeric() const noexcept;
    operator double() const noexcept;

    int64_t num() const noexcept { return m_num; }
    int64_t denom() const noexcept { return m_den; }
    GncNumeric operator-() const noexcept;
    GncNumeric inv() const noexcept;
    GncNumeric abs() const noexcept;
    GncNumeric reduce() const noexcept;
    template <RoundType RT>
    GncNumeric convert(int64_t new_denom) const
    {
        auto params = prepare_conversion(new_denom);
        if (new_denom == GNC_DENOM_AUTO)
            new_denom = m_den;
        if (params.rem == 0)
            return GncNumeric(params.num, new_denom);
        return GncNumeric(round(params.num, params.den,
                                params.rem, RT2T<RT>()), new_denom);
    }

    template <RoundType RT>
    GncNumeric 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 GncNumeric(params.num, new_denom);
        return GncNumeric(round(params.num, params.den,
                                params.rem, RT2T<RT>()), new_denom);
    }
    std::string to_string() const noexcept;
    bool is_decimal() const noexcept;
    GncNumeric to_decimal(unsigned int max_places=17) const;
    void operator+=(GncNumeric b);
    void operator-=(GncNumeric b);
    void operator*=(GncNumeric b);
    void operator/=(GncNumeric b);
    /* @} */
    int cmp(GncNumeric b);
    int cmp(int64_t b) { return cmp(GncNumeric(b, 1)); }
private:
    struct round_param
    {
        int64_t num;
        int64_t den;
        int64_t rem;
    };
    /* Calculates the denominator required to convert to figs sigfigs. */
    int64_t 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(int64_t new_denom) const;
    int64_t m_num;
    int64_t m_den;
};

GncNumeric operator+(GncNumeric a, GncNumeric b);
inline GncNumeric operator+(GncNumeric a, int64_t b)
{
    return a + GncNumeric(b, 1);
}
inline GncNumeric operator+(int64_t a, GncNumeric b)
{
    return b + GncNumeric(a, 1);
}
GncNumeric operator-(GncNumeric a, GncNumeric b);
inline GncNumeric operator-(GncNumeric a, int64_t b)
{
    return a - GncNumeric(b, 1);
}
inline GncNumeric operator-(int64_t a, GncNumeric b)
{
    return b - GncNumeric(a, 1);
}
GncNumeric operator*(GncNumeric a, GncNumeric b);
inline GncNumeric operator*(GncNumeric a, int64_t b)
{
    return a * GncNumeric(b, 1);
}
inline GncNumeric operator*(int64_t a, GncNumeric b)
{
    return b * GncNumeric(a, 1);
}
GncNumeric operator/(GncNumeric a, GncNumeric b);
inline GncNumeric operator/(GncNumeric a, int64_t b)
{
    return a / GncNumeric(b, 1);
}
inline GncNumeric operator/(int64_t a, GncNumeric b)
{
    return b / GncNumeric(a, 1);
}
std::ostream& operator<<(std::ostream&, GncNumeric);

/* Implementation adapted from "The C++ Standard Library, Second Edition" by
 * Nicolai M. Josuttis, Addison-Wesley, 2012, ISBN 978-0-321-62321-8.
 */
template <typename charT, typename traits>
std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& s, GncNumeric n)
{
    std::basic_ostringstream<charT, traits> ss;
    std::locale loc = s.getloc();
    ss.imbue(loc);
    auto dec_pt = static_cast<charT>('.');
    try
    {
        dec_pt = std::use_facet<std::numpunct<charT>>(loc).decimal_point();
    }
    catch(const std::bad_cast& err) {} //Don't do anything, num_sep is already set.

    ss.copyfmt(s);
    ss.width(0);
    if (n.denom() == 1)
         ss << n.num();
    else if (n.is_decimal())
        ss << n.num() / n.denom() << dec_pt
           << (n.num() > 0 ? n.num() : -n.num()) % n.denom();
    else
        ss << n.num() << "/" << n.denom();
    s << ss.str();
    return s;
}

/* Implementation adapted from "The C++ Standard Library, Second Edition" by
 * Nicolai M. Josuttis, Addison-Wesley, 2012, ISBN 978-0-321-62321-8.
 */
template <typename charT, typename traits>
std::basic_istream<charT, traits>& operator>>(std::basic_istream<charT, traits>& s, GncNumeric& n)
{
    std::basic_string<charT, traits> instr;
    s >> instr;
    if (s)
        n = GncNumeric(instr, true);
    return s;
}

inline int cmp(GncNumeric a, GncNumeric b) { return a.cmp(b); }
inline int cmp(GncNumeric a, int64_t b) { return a.cmp(b); }
inline int cmp(int64_t a, GncNumeric b) { return GncNumeric(a, 1).cmp(b); }

inline bool operator<(GncNumeric a, GncNumeric b) { return cmp(a, b) < 0; }
inline bool operator<(GncNumeric a, int64_t b) { return cmp(a, b) < 0; }
inline bool operator<(int64_t a, GncNumeric b) { return cmp(a, b) < 0; }
inline bool operator>(GncNumeric a, GncNumeric b) { return cmp(a, b) > 0; }
inline bool operator>(GncNumeric a, int64_t b) { return cmp(a, b) > 0; }
inline bool operator>(int64_t a, GncNumeric b) { return cmp(a, b) > 0; }
inline bool operator==(GncNumeric a, GncNumeric b) { return cmp(a, b) == 0; }
inline bool operator==(GncNumeric a, int64_t b) { return cmp(a, b) == 0; }
inline bool operator==(int64_t a, GncNumeric b) { return cmp(a, b) == 0; }
inline bool operator<=(GncNumeric a, GncNumeric b) { return cmp(a, b) <= 0; }
inline bool operator<=(GncNumeric a, int64_t b) { return cmp(a, b) <= 0; }
inline bool operator<=(int64_t a, GncNumeric b) { return cmp(a, b) <= 0; }
inline bool operator>=(GncNumeric a, GncNumeric b) { return cmp(a, b) >= 0; }
inline bool operator>=(GncNumeric a, int64_t b) { return cmp(a, b) >= 0; }
inline bool operator>=(int64_t a, GncNumeric b) { return cmp(a, b) >= 0; }
inline bool operator!=(GncNumeric a, GncNumeric b) { return cmp(a, b) != 0; }
inline bool operator!=(GncNumeric a, int64_t b) { return cmp(a, b) != 0; }
inline bool operator!=(int64_t a, GncNumeric b) { return cmp(a, b) != 0; }
int64_t powten(unsigned int digits);

#endif // __GNC_NUMERIC_HPP__