integer.hpp

/*********************************************************************
 *
 * Linear Arrangement Library - A library that implements a collection
 * algorithms for linear arrangments of graphs.
 *
 * Copyright (C) 2019 - 2023
 *
 * This file is part of Linear Arrangement Library. The full code is available
 * at:
 *      https://github.com/LAL-project/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); }
#ifndef SWIG
    integer(mpz_t&& raw) noexcept {
        // move raw's contents
        *m_val = *raw;
        m_initialized = true;
        
        // invalidate raw's contents
        raw->_mp_alloc = 0;
        raw->_mp_size = 0;
        raw->_mp_d = nullptr;
    }
#endif
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer(T i) noexcept {
        if constexpr (std::is_signed_v<T>) { mpz_init_set_si(m_val, i); }
        else { mpz_init_set_ui(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 {
        // move i's contents
        *m_val = *i.m_val;
        
        // invalidate i's contents
        i.m_val->_mp_alloc = 0;
        i.m_val->_mp_size = 0;
        i.m_val->_mp_d = nullptr;
        i.m_initialized = false;
    }
#endif
    integer(const integer& i) noexcept { mpz_init_set(m_val, i.m_val); }
    ~integer() noexcept { mpz_clear(m_val); }
 
    /* SETTERS */
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    void set_number(T i) noexcept {
        if (not is_initialized()) { mpz_init(m_val); }
        if constexpr (std::is_signed_v<T>) { mpz_set_si(m_val, i); }
        else { mpz_set_ui(m_val, i); }
        m_initialized = true;
    }
 
    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;
    }
    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
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer& operator= (T i) noexcept {
        set_number(i);
        return *this;
    }
    integer& operator= (const integer& i) noexcept {
        set_integer(i);
        return *this;
    }
    integer& operator= (integer&& i) noexcept {
        mpz_clear(m_val);
 
        // move i's contents
        *m_val = *i.m_val;
        m_initialized = true;
        
        // invalidate i's contents
        i.m_val->_mp_alloc = 0;
        i.m_val->_mp_size = 0;
        i.m_val->_mp_d = nullptr;
        i.m_initialized = false;
 
        return *this;
    }
#endif
 
    // -- EQUALITY
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    bool operator== (T i) const noexcept {
        return
        (std::is_signed_v<T> ? mpz_cmp_si(m_val,i) : mpz_cmp_ui(m_val,i)) == 0;
    }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend bool operator== (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; }
 
    // -- NON-EQUALITY
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    bool operator!= (T i) const noexcept
    { return not (*this == i); }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend bool operator!= (T i, const integer& ii) noexcept
    { return ii != i; }
#endif
    bool operator!= (const integer& i) const noexcept
    { return not (*this == i); }
 
    // -- LESS THAN
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    bool operator< (T i) const noexcept {
        return
        (std::is_signed_v<T> ? mpz_cmp_si(m_val, i) : mpz_cmp_ui(m_val, i)) < 0;
    }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend bool operator< (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
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    bool operator<= (T i) const noexcept {
        return
        (std::is_signed_v<T> ? mpz_cmp_si(m_val, i) : mpz_cmp_ui(m_val, i)) <= 0;
    }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend bool operator<= (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; }
 
    // -- GREATER THAN
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    bool operator> (T i) const noexcept {
        return
        (std::is_signed_v<T> ? mpz_cmp_si(m_val, i) : mpz_cmp_ui(m_val, i)) > 0;
    }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend bool operator> (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; }
 
    // -- GREATER THAN OR EQUAL TO
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    bool operator>= (T i) const noexcept {
        return
        (std::is_signed_v<T> ? mpz_cmp_si(m_val, i) : mpz_cmp_ui(m_val, i)) >= 0;
    }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend bool operator>= (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; }
 
    /* ARITHMETIC OPERATORS */
 
    // -- ADDITION
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer operator+ (T i) const noexcept
    { integer a(*this); a += i; return a; }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend integer operator+ (T i, const integer& ii) noexcept
    { return ii + i; }
#endif
    integer operator+ (const integer& i) const noexcept
    { integer a(*this); a += i; return a; }
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer& operator+= (T i) noexcept {
        if constexpr (not std::is_signed_v<T>) { mpz_add_ui(m_val, m_val, i); }
        else {
            if (i > 0) {mpz_add_ui(m_val, m_val, static_cast<uint64_t>(i)); }
            else {      mpz_sub_ui(m_val, m_val, static_cast<uint64_t>(-i));}
        }
        return *this;
    }
    integer& operator+= (const integer& i) noexcept
    { mpz_add(m_val, m_val, i.m_val); return *this; }
 
    // -- SUBSTRACTION
 
    integer operator- () const noexcept
    { integer a(*this); mpz_neg(a.m_val, a.m_val); return a; }
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer operator- (T i) const noexcept
    { integer a(*this); a -= i; return a; }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend integer operator- (T i, const integer& ii) noexcept
    { return -ii + i; }
#endif
    integer operator- (const integer& i) const noexcept
    { integer a(*this); a -= i; return a; }
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer& operator-= (T i) noexcept {
        if constexpr (not std::is_signed_v<T>) { mpz_sub_ui(m_val, m_val, i); }
        else {
            if (i > 0) {mpz_sub_ui(m_val, m_val, static_cast<uint64_t>(i)); }
            else {      mpz_add_ui(m_val, m_val, static_cast<uint64_t>(-i));}
        }
        return *this;
    }
    integer& operator-= (const integer& i) noexcept
    { mpz_sub(m_val, m_val, i.m_val); return *this; }
 
    // -- MULTIPLICATION
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer operator* (T i) const noexcept
    { integer a(*this); a *= i; return a; }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend integer operator* (T i, const integer& ii) noexcept
    { return ii*i; }
#endif
 
    integer operator* (const integer& i) const noexcept
    { integer a(*this); a *= i; return a; }
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer& operator*= (T i) noexcept {
        if constexpr (std::is_signed_v<T>) { mpz_mul_si(m_val, m_val, i); }
        else {                               mpz_mul_ui(m_val, m_val, i); }
        return *this;
    }
    integer& operator*= (const integer& i) noexcept
    { mpz_mul(m_val, m_val, i.m_val);   return *this; }
 
    // -- DIVISION
 
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer operator/ (T i) const noexcept
    { integer a(*this); a /= i; return a; }
#ifndef SWIG
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    friend int64_t operator/ (T i, const integer& ii) noexcept
    { return i/ii.to_int(); }
#endif
    integer operator/ (const integer& i) const noexcept
    { integer a(*this); a /= i; return a; }
    template <typename T,std::enable_if_t<std::is_integral_v<T>, bool> = true>
    integer& operator/= (T i) noexcept {
        if constexpr (not std::is_signed_v<T>) {
            mpz_fdiv_q_ui(m_val, m_val, i);
        }
        else {
            mpz_fdiv_q_ui(m_val, m_val, static_cast<uint64_t>(i<0 ? -i : i));
            mpz_mul_si(m_val, m_val, (i<0 ? -1 : 1));
        }
        return *this;
    }
    integer& operator/= (const integer& i) noexcept
    { mpz_div(m_val, m_val, i.m_val); return *this; }
 
    // -- EXPONENTIATION
 
    integer power(uint64_t i) const noexcept
    { integer r(*this); r.powt(i);  return r; }
    integer power(const integer& i) const noexcept
    { integer r(*this); r.powt(i);  return r; }
 
    integer& powt(uint64_t i) noexcept
    { mpz_pow_ui(m_val, m_val, i); return *this; }
    integer& powt(const integer& i) noexcept;
 
    // -- MODULUS
 
    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;
    }
    integer operator% (const integer& i) const noexcept {
        integer r;
        mpz_mod(r.m_val, m_val, i.m_val);
        return r;
    }
 
    /* GETTERS */
 
    constexpr bool is_initialized() const noexcept { return m_initialized; }
    int64_t get_sign() const noexcept { return mpz_sgn(m_val); }
 
    std::size_t bytes() const noexcept;
    const mpz_t& get_raw_value() const noexcept { return m_val; }
 
    /* CONVERTERS */
 
    int64_t to_int() const noexcept { return mpz_get_si(m_val); }
    uint64_t to_uint() const noexcept { return mpz_get_ui(m_val); }
    double to_double() const noexcept { return mpz_get_d(m_val); }
 
    std::string to_string() const noexcept {
        std::string k;
        as_string(k);
        return k;
    }
    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 */
 
    void swap(integer& i) noexcept { mpz_swap(m_val, i.m_val); }
 
#ifndef SWIG
    friend void swap(integer& i, integer& j) noexcept {
        i.swap(j);
    }
#endif
 
private:
    mpz_t m_val;
    bool m_initialized = true;
};
 
} // -- namespace numeric
} // -- namespace lal