integer.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
 
// gmp includes
#include <gmp.h>
 
// C++ includes
#include <cstdint>
#include <string>
 
namespace lal {
namespace numeric {
 
class integer {
public:
    friend class rational;
public:
    /* CONSTRUCTORS */
 
    integer() noexcept { mpz_init(m_val); }
    integer(mpz_t&& raw);
    integer(int64_t i) noexcept { mpz_init_set_si(m_val, i); }
    integer(const std::string& s) noexcept { mpz_init_set_str(m_val, s.c_str(), 10); }
#ifndef SWIG
    integer(integer&& i) noexcept;
#endif
    integer(const integer& i) noexcept { mpz_init_set(m_val, i.m_val); }
    ~integer() noexcept { mpz_clear(m_val); }
 
    /* SETTERS */
 
    inline void set_si(int64_t i) noexcept {
        if (not is_initialized()) { mpz_init(m_val); }
        mpz_set_si(m_val, i);
        m_initialized = true;
    }
    inline void set_ui(uint64_t i) noexcept {
        if (not is_initialized()) { mpz_init(m_val); }
        mpz_set_ui(m_val, i);
        m_initialized = true;
    }
    inline void set_integer(const integer& i) noexcept {
        if (not is_initialized()) { mpz_init(m_val); }
        mpz_set(m_val, i.m_val);
        m_initialized = true;
    }
    inline void set_str(const std::string& s) noexcept {
        if (not is_initialized()) { mpz_init(m_val); }
        mpz_set_str(m_val, s.c_str(), 10);
        m_initialized = true;
    }
 
    /* OPERATORS */
 
    // -- ASSIGNMENT
 
#ifndef SWIG
    inline integer& operator= (int64_t i) noexcept {
        set_si(i);
        return *this;
    }
    inline integer& operator= (const integer& i) noexcept {
        set_integer(i);
        return *this;
    }
    integer& operator= (integer&& i) noexcept;
#endif
 
    // -- EQUALITY
 
    inline bool operator== (int64_t i) const noexcept
    { return mpz_cmp_si(m_val, i) == 0; }
#ifndef SWIG
    inline bool friend operator== (int64_t i, const integer& ii) noexcept
    { return ii == i; }
#endif
    inline bool operator== (const integer& i) const noexcept
    { return mpz_cmp(m_val, i.m_val) == 0; }
 
    // -- NON-EQUALITY
 
    inline bool operator!= (int64_t i) const noexcept
    { return not (*this == i); }
#ifndef SWIG
    inline bool friend operator!= (int64_t i, const integer& ii) noexcept
    { return ii != i; }
#endif
    inline bool operator!= (const integer& i) const noexcept
    { return not (*this == i); }
 
    // -- LESS THAN
 
    inline bool operator< (int64_t i) const noexcept
    { return mpz_cmp_si(m_val, i)  < 0; }
#ifndef SWIG
    inline friend bool operator< (int64_t i, const integer& ii) noexcept
    { return ii > i; }
#endif
    bool operator< (const integer& i) const noexcept
    { return mpz_cmp(m_val, i.m_val) < 0; }
 
    // -- LESS THAN OR EQUAL TO
 
    inline bool operator<= (int64_t i) const noexcept
    { return mpz_cmp_si(m_val, i)  <= 0; }
#ifndef SWIG
    inline friend bool operator<= (int64_t i, const integer& ii) noexcept
    { return ii >= i; }
#endif
    inline bool operator<= (const integer& i) const noexcept
    { return mpz_cmp(m_val, i.m_val) <= 0; }
 
    // -- GREATER THAN
 
    inline bool operator> (int64_t i) const noexcept
    { return mpz_cmp_si(m_val, i)  > 0; }
#ifndef SWIG
    inline friend bool operator> (int64_t i, const integer& ii) noexcept
    { return ii < i; }
#endif
    inline bool operator> (const integer& i) const noexcept
    { return mpz_cmp(m_val, i.m_val) > 0; }
 
    // -- GREATER THAN OR EQUAL TO
 
    inline bool operator>= (int64_t i) const noexcept
    { return mpz_cmp_si(m_val, i) >= 0; }
#ifndef SWIG
    inline friend bool operator>= (int64_t i, const integer& ii) noexcept
    { return ii <= i; }
#endif
    inline bool operator>= (const integer& i) const noexcept
    { return mpz_cmp(m_val, i.m_val) >= 0; }
 
    /* ARITHMETIC OPERATORS */
 
    // -- ADDITION
 
    inline integer operator+ (int64_t i) const noexcept
    { integer a(*this); a += i; return a; }
#ifndef SWIG
    inline friend integer operator+ (int64_t i, const integer& ii) noexcept
    { return ii + i; }
#endif
    inline integer operator+ (const integer& i) const noexcept
    { integer a(*this); a += i; return a; }
    integer& operator+= (int64_t i) noexcept;
    integer& operator+= (const integer& i) noexcept
    { mpz_add(m_val, m_val, i.m_val); return *this; }
 
    // -- SUBSTRACTION
 
    inline integer operator- () const noexcept
    { integer a(*this); mpz_neg(a.m_val, a.m_val); return a; }
    inline integer operator- (int64_t i) const noexcept
    { integer a(*this); a -= i; return a; }
#ifndef SWIG
    inline friend integer operator- (int64_t i, const integer& ii) noexcept
    { return -ii + i; }
#endif
    inline integer operator- (const integer& i) const noexcept
    { integer a(*this); a -= i; return a; }
    integer& operator-= (int64_t i) noexcept;
    inline integer& operator-= (const integer& i) noexcept
    { mpz_sub(m_val, m_val, i.m_val); return *this; }
 
    // -- MULTIPLICATION
 
    inline integer operator* (int64_t i) const noexcept
    { integer a(*this); a *= i; return a; }
#ifndef SWIG
    inline friend integer operator* (int64_t i, const integer& ii) noexcept
    { return ii*i; }
#endif
    inline integer operator* (const integer& i) const noexcept
    { integer a(*this); a *= i; return a; }
    inline integer& operator*= (int64_t i) noexcept
    { mpz_mul_si(m_val, m_val, i);      return *this; }
    inline integer& operator*= (const integer& i) noexcept
    { mpz_mul(m_val, m_val, i.m_val);   return *this; }
 
    // -- DIVISION
 
    inline integer operator/ (int64_t i) const noexcept
    { integer a(*this); a /= i; return a; }
#ifndef SWIG
    inline friend int64_t operator/ (int64_t i, const integer& ii) noexcept
    {
        return i/ii.to_int();
    }
#endif
    inline integer operator/ (const integer& i) const noexcept
    { integer a(*this); a /= i; return a; }
    integer& operator/= (int64_t i) noexcept;
    inline integer& operator/= (const integer& i) noexcept
    { mpz_div(m_val, m_val, i.m_val); return *this; }
 
    // -- EXPONENTIATION
 
    inline integer pow(uint64_t i) const noexcept
    { integer r(*this); r.powt(i);  return r; }
    inline integer pow(const integer& i) const noexcept
    { integer r(*this); r.powt(i);  return r; }
 
    inline integer& powt(uint64_t i) noexcept
    { mpz_pow_ui(m_val, m_val, i); return *this; }
    integer& powt(const integer& i) noexcept;
 
    // -- MODULUS
 
    inline uint64_t operator% (uint64_t i) const noexcept {
        mpz_t r;
        mpz_init(r);
        const uint64_t m = mpz_mod_ui(r, m_val, i);
        mpz_clear(r);
        return m;
    }
    inline integer operator% (const integer& i) const noexcept {
        integer r;
        mpz_mod(r.m_val, m_val, i.m_val);
        return r;
    }
 
    /* GETTERS */
 
    inline constexpr bool is_initialized() const noexcept { return m_initialized; }
    inline int32_t get_sign() const noexcept { return mpz_sgn(m_val); }
 
    size_t bytes() const noexcept;
    inline const mpz_t& get_raw_value() const noexcept { return m_val; }
 
    /* CONVERTERS */
 
    inline int64_t to_int() const noexcept { return mpz_get_si(m_val); }
    inline uint64_t to_uint() const noexcept { return mpz_get_ui(m_val); }
    inline double to_double() const noexcept { return mpz_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 = mpz_get_str(buf, 10, m_val);
        s = std::string(buf);
        free(buf);
    }
 
    /* OTHERS */
 
    inline void swap(integer& i) noexcept { mpz_swap(m_val, i.m_val); }
 
#ifndef SWIG
    inline friend void swap(integer& i, integer& j) noexcept {
        i.swap(j);
    }
#endif
 
private:
    mpz_t m_val;
    bool m_initialized = true;
};
 
inline integer integer_from_ui(uint64_t n) noexcept {
    integer i;
    i.set_ui(n);
    return i;
}
 
} // -- namespace numeric
} // -- namespace lal