rational.hpp

/*********************************************************************
 *
 *  Linear Arrangement Library - A library that implements a collection
 *  algorithms for linear arrangments of graphs.
 *
 *  Copyright (C) 2019 - 2021
 *
 *  This file is part of Linear Arrangement Library. To see the full code
 *  visit the webpage:
 *      https://github.com/lluisalemanypuig/linear-arrangement-library.git
 *
 *  Linear Arrangement Library is free software: you can redistribute it
 *  and/or modify it under the terms of the GNU Affero General Public License
 *  as published by the Free Software Foundation, either version 3 of the
 *  License, or (at your option) any later version.
 *
 *  Linear Arrangement Library 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 Affero General Public License for more details.
 *
 *  You should have received a copy of the GNU Affero General Public License
 *  along with Linear Arrangement Library.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Contact:
 *
 *      Lluís Alemany Puig (lalemany@cs.upc.edu)
 *          LARCA (Laboratory for Relational Algorithmics, Complexity and Learning)
 *          CQL (Complexity and Quantitative Linguistics Lab)
 *          Jordi Girona St 1-3, Campus Nord UPC, 08034 Barcelona.   CATALONIA, SPAIN
 *          Webpage: https://cqllab.upc.edu/people/lalemany/
 *
 *      Ramon Ferrer i Cancho (rferrericancho@cs.upc.edu)
 *          LARCA (Laboratory for Relational Algorithmics, Complexity and Learning)
 *          CQL (Complexity and Quantitative Linguistics Lab)
 *          Office S124, Omega building
 *          Jordi Girona St 1-3, Campus Nord UPC, 08034 Barcelona.   CATALONIA, SPAIN
 *          Webpage: https://cqllab.upc.edu/people/rferrericancho/
 *
 ********************************************************************/
 
#pragma once
 
// C includes
#include <gmp.h>
 
// C++ includes
#include <cstdint>
#include <string>
 
// lal includes
#include <lal/numeric/integer.hpp>
 
namespace lal {
namespace numeric {
 
class rational {
public:
    /* CONSTRUCTORS */
 
    rational() noexcept { mpq_init(m_val); }
    rational(int64_t n, uint64_t d = 1) noexcept
    { mpq_init(m_val); set_si(n, d); }
    rational(const integer& n, const integer& d = 1) noexcept
    { mpq_init(m_val); set_integer(n, d); }
    rational(const std::string& s) noexcept
    { mpq_init(m_val); set_str(s); }
    rational(const rational& r) noexcept
    { mpq_init(m_val); mpq_set(m_val, r.m_val); }
#ifndef SWIG
    rational(integer&& v) noexcept;
    rational(integer&& n, integer&& d) noexcept;
    rational(rational&& r) noexcept;
#endif
    ~rational() noexcept { mpq_clear(m_val); }
 
    /* SETTERS */
 
    inline void set_si(int64_t n, uint64_t d = 1) noexcept {
        if (not is_initialized()) { mpq_init(m_val); }
        mpq_set_si(m_val, n, d);
        mpq_canonicalize(m_val);
        m_initialized = true;
    }
    inline void set_ui(uint64_t n, uint64_t d = 1) noexcept {
        if (not is_initialized()) { mpq_init(m_val); }
        mpq_set_ui(m_val, n, d);
        mpq_canonicalize(m_val);
        m_initialized = true;
    }
    inline void set_str(const std::string& s) noexcept {
        if (not is_initialized()) { mpq_init(m_val); }
        mpq_set_str(m_val, s.c_str(), 10);
        mpq_canonicalize(m_val);
        m_initialized = true;
    }
    inline void set_integer(const integer& n, const integer& d) noexcept {
        if (not is_initialized()) { mpq_init(m_val); }
        mpq_set_num(m_val, n.get_raw_value());
        mpq_set_den(m_val, d.get_raw_value());
        mpq_canonicalize(m_val);
        m_initialized = true;
    }
    inline void set_rational(const rational& r) noexcept {
        if (not is_initialized()) { mpq_init(m_val); }
        mpq_set(m_val, r.m_val);
    }
 
    inline void invert() noexcept { mpq_inv(m_val, m_val); }
 
    /* OPERATORS */
 
    // -- ASSIGNMENT
 
    inline rational& operator= (int64_t i) noexcept
    { set_si(i); return *this; }
    inline rational& operator= (const std::string& s) noexcept
    { set_str(s); return *this; }
    inline rational& operator= (const integer& i) noexcept
    { set_integer(i, 1); return *this; }
    inline rational& operator= (const rational& r) noexcept
    { set_rational(r); return *this; }
#ifndef SWIG
    rational& operator= (integer&& i) noexcept;
    rational& operator= (rational&& r) noexcept;
#endif
 
    // -- EQUALITY
 
    inline bool operator== (int64_t i) const noexcept
    { rational r(i); return mpq_equal(m_val, r.m_val) != 0; }
#ifndef SWIG
    inline friend bool operator== (int64_t i, const rational& r) noexcept
    { return r == i; }
#endif
    inline bool operator== (const integer& i) const noexcept
    { rational r(i); return mpq_equal(m_val, r.m_val) != 0; }
#ifndef SWIG
    inline friend bool operator== (const integer& i, const rational& r) noexcept
    { return r == i; }
#endif
    inline bool operator== (const rational& r) const noexcept
    { return mpq_equal(m_val, r.m_val) != 0; }
 
    // -- NON-EQUALITY
 
    inline bool operator!= (int64_t i) const noexcept
    { return not (*this == i); }
#ifndef SWIG
    inline friend bool operator!= (int64_t i, const rational& r) noexcept
    { return r != i; }
#endif
    inline bool operator!= (const integer& i) const noexcept
    { return not (*this == i); }
#ifndef SWIG
    inline friend bool operator!= (const integer& i, const rational& r) noexcept
    { return r != i; }
#endif
    inline bool operator!= (const rational& r) const noexcept
    { return not (*this == r); }
 
    // -- LESS THAN
 
    inline bool operator< (int64_t i) const noexcept
    { rational r(i); return mpq_cmp(m_val, r.m_val) < 0; }
#ifndef SWIG
    inline friend bool operator< (int64_t i, const rational& r) noexcept
    { return r > i; }
#endif
    inline bool operator< (const integer& i) const noexcept
    { rational r(i); return mpq_cmp(m_val, r.m_val) < 0; }
#ifndef SWIG
    inline friend bool operator< (const integer& i, const rational& r) noexcept
    { return r > i; }
#endif
    inline bool operator< (const rational& r) const noexcept
    { return mpq_cmp(m_val, r.m_val) < 0; }
 
    // -- LESS THAN OR EQUAL TO
 
    inline bool operator<= (int64_t i) const noexcept
    { rational r(i); return mpq_cmp(m_val, r.m_val) <= 0; }
#ifndef SWIG
    inline friend bool operator<= (int64_t i, const rational& r) noexcept
    { return r >= i; }
#endif
    inline bool operator<= (const integer& i) const noexcept
    { rational r(i); return mpq_cmp(m_val, r.m_val) <= 0; }
#ifndef SWIG
    inline friend bool operator<= (const integer& i, const rational& r) noexcept
    { return r >= i; }
#endif
    inline bool operator<= (const rational& r) const noexcept
    { return mpq_cmp(m_val, r.m_val) <= 0; }
 
    // -- GREATER THAN
 
    inline bool operator> (int64_t i) const noexcept
    { rational r(i); return mpq_cmp(m_val, r.m_val) > 0; }
#ifndef SWIG
    inline friend bool operator> (int64_t i, const rational& r) noexcept
    { return r < i; }
#endif
    inline bool operator> (const integer& i) const noexcept
    { rational r(i); return mpq_cmp(m_val, r.m_val) > 0; }
#ifndef SWIG
    inline friend bool operator> (const integer& i, const rational& r) noexcept
    { return r < i; }
#endif
    inline bool operator> (const rational& r) const noexcept
    { return mpq_cmp(m_val, r.m_val) > 0; }
 
    // -- GREATER THAN OR EQUAL TO
 
    inline bool operator>= (int64_t i) const noexcept
    { rational r(i); return mpq_cmp(m_val, r.m_val) >= 0; }
#ifndef SWIG
    inline friend bool operator>= (int64_t i, const rational& r) noexcept
    { return r <= i; }
#endif
    inline bool operator>= (const integer& i) const noexcept
    { rational r(i); return mpq_cmp(m_val, r.m_val) >= 0; }
#ifndef SWIG
    inline friend bool operator>= (const integer& i, const rational& r) noexcept
    { return r <= i; }
#endif
    inline bool operator>= (const rational& r) const noexcept
    { return mpq_cmp(m_val, r.m_val) >= 0; }
 
    // -- ADDITION
 
    inline rational operator+ (int64_t i) const noexcept
    { rational r(*this); r += i; return r; }
#ifndef SWIG
    inline friend rational operator+ (int64_t i, const rational& r) noexcept
    { return r + i; }
#endif
    inline rational operator+ (const integer& i) const noexcept
    { rational r(*this); r += i; return r; }
#ifndef SWIG
    inline friend rational operator+ (const integer& i, const rational& r) noexcept
    { return r + i; }
#endif
    inline rational operator+ (const rational& r) const noexcept
    { rational k(*this); k += r; return k; }
 
    inline rational& operator+= (int64_t i) noexcept
    { rational r(i); mpq_add(m_val, m_val, r.m_val); return *this; }
    inline rational& operator+= (const integer& i) noexcept
    { rational r(i); mpq_add(m_val, m_val, r.m_val); return *this; }
    inline rational& operator+= (const rational& r) noexcept
    { mpq_add(m_val, m_val, r.m_val); return *this; }
 
    // -- SUBSTRACTION
 
    inline rational operator- () const noexcept
    { rational r(*this); mpq_neg(r.m_val, r.m_val); return r; }
    inline rational operator- (int64_t i) const noexcept
    { rational r(*this); r -= i; return r; }
#ifndef SWIG
    inline friend rational operator- (int64_t i, const rational& r) noexcept
    { return -r + i; }
#endif
    inline rational operator- (const integer& i) const noexcept
    { rational r(*this); r -= i; return r; }
#ifndef SWIG
    inline friend rational operator- (const integer& i, const rational& r) noexcept
    { return -r + i; }
#endif
    inline rational operator- (const rational& r) const noexcept
    { rational k(*this); k -= r; return k; }
 
    inline rational& operator-= (int64_t i) noexcept
    { rational r(i); mpq_sub(m_val, m_val, r.m_val); return *this; }
    inline rational& operator-= (const integer& i) noexcept
    { rational r(i); mpq_sub(m_val, m_val, r.m_val); return *this; }
    inline rational& operator-= (const rational& r) noexcept
    { mpq_sub(m_val, m_val, r.m_val); return *this; }
 
    // -- MULTIPLICATION
 
    inline rational operator* (int64_t i) const noexcept
    { rational r(*this); r *= i; return r; }
#ifndef SWIG
    inline friend rational operator* (int64_t i, const rational& r) noexcept
    { return r*i; }
#endif
    inline rational operator* (const integer& i) const noexcept
    { rational r(*this); r *= i; return r; }
#ifndef SWIG
    inline friend rational operator* (const integer& i, const rational& r) noexcept
    { return r*i; }
#endif
    inline rational operator* (const rational& r) const noexcept
    { rational k(*this); k *= r; return k; }
 
    inline rational& operator*= (int64_t i) noexcept
    { rational r(i); mpq_mul(m_val, m_val, r.m_val); return *this; }
    inline rational& operator*= (const integer& i) noexcept
    { rational r(i); mpq_mul(m_val, m_val, r.m_val); return *this; }
    inline rational& operator*= (const rational& r) noexcept
    { mpq_mul(m_val, m_val, r.m_val); return *this; }
 
    // -- DIVISION
 
    inline rational operator/ (int64_t i) const noexcept
    { rational r(*this); r /= i; return r; }
#ifndef SWIG
    inline friend rational operator/ (int64_t i, const rational& r) noexcept
    { rational inv(r); inv.invert(); return inv*i; }
#endif
 
    inline rational operator/ (const integer& i) const noexcept
    { rational r(*this); r /= i; return r; }
    inline rational operator/ (const rational& r) const noexcept
    { rational k(*this); k /= r; return k; }
 
    rational& operator/= (int64_t i) noexcept;
    rational& operator/= (const integer& i) noexcept;
    rational& operator/= (const rational& r) noexcept;
 
    // -- EXPONENTIATION
 
    rational pow(uint64_t i) const noexcept;
    rational pow(const integer& i) const noexcept;
 
    rational& powt(uint64_t i) noexcept;
    rational& powt(const integer& i) noexcept;
 
    /* GETTERS */
 
    inline bool is_initialized() const noexcept { return m_initialized; }
    inline int32_t get_sign() const noexcept { return mpq_sgn(m_val); }
 
    size_t bytes() const noexcept;
 
    /* CONVERTERS */
 
    inline integer to_integer() const noexcept {
        integer i;
        as_integer(i);
        return i;
    }
    void as_integer(integer& i) const noexcept;
 
    inline double to_double() const noexcept { return mpq_get_d(m_val); }
    inline void as_double(double& d) const noexcept { d = mpq_get_d(m_val); }
 
    inline std::string to_string() const noexcept {
        std::string k;
        as_string(k);
        return k;
    }
    inline void as_string(std::string& s) const noexcept {
        char *buf = nullptr;
        buf = mpq_get_str(buf, 10, m_val);
        s = std::string(buf);
        free(buf);
    }
 
    inline integer get_numerator() const noexcept {
        mpz_t numerator;
        mpz_init(numerator);
        mpq_get_num(numerator, m_val);
        return integer(std::move(numerator));
    }
 
    inline integer get_denominator() const noexcept {
        mpz_t denominator;
        mpz_init(denominator);
        mpq_get_den(denominator, m_val);
        return integer(std::move(denominator));
    }
 
    /* OTHERS */
 
    void swap(rational& r) noexcept { mpq_swap(m_val, r.m_val); }
 
#ifndef SWIG
    friend void swap(rational& r1, rational& r2) noexcept { r1.swap(r2); }
#endif
 
private:
    mpq_t m_val;
    bool m_initialized = true;
};
 
inline rational rational_from_ui(uint64_t n, uint64_t d = 1) noexcept {
    rational R;
    R.set_ui(n, d);
    return R;
}
 
} // -- namespace numeric
} // -- namespace lal