big_integer.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include "bytes_view.h"
 
#include "detail/config.h"
#include "detail/mpi.h"
 
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>
 
namespace ignite {

class big_integer {
    friend class big_decimal;
 
    using mpi_t = detail::mpi;
    using word_t = mpi_t::word;
 
public:
    // Magnitude array type.
    using mag_array_view = mpi_t::mag_view;

    big_integer() = default;

    big_integer(const big_integer &other) = default;

    big_integer(big_integer &&other) noexcept = default;

    explicit big_integer(std::int64_t val) { assign_int64(val); }

    explicit big_integer(const std::string &val) { assign_string(val); }

    big_integer(const char *val, std::int32_t len) { assign_string(val, len); }

    big_integer(const std::int8_t *val, std::int32_t len, std::int8_t sign, bool big_endian = true);

    big_integer(const std::byte *data, std::size_t size);

    big_integer &operator=(const big_integer &other) = default;

    big_integer &operator=(big_integer &&other) noexcept = default;

    big_integer &operator=(const mpi_t &other) {
        if (&other == &this->m_mpi) {
            return *this;
        }
 
        m_mpi = other;
 
        return *this;
    }

    big_integer &operator=(mpi_t &&other) noexcept {
        using std::swap;
 
        if (&other == &this->m_mpi) {
            return *this;
        }
 
        swap(m_mpi, other);
 
        return *this;
    }

    void assign_int64(std::int64_t val);

    void assign_uint64(std::uint64_t val);

    void assign_string(const std::string &val);

    void assign_string(const char *val, std::size_t len);

    [[nodiscard]] std::int8_t get_sign() const noexcept { return std::int8_t(m_mpi.sign()); }

    [[nodiscard]] mag_array_view get_magnitude() const noexcept { return m_mpi.magnitude(); }

    [[nodiscard]] std::uint32_t bit_length() const noexcept;

    [[nodiscard]] std::size_t byte_size() const noexcept;

    void store_bytes(std::byte *data) const;

    [[nodiscard]] std::vector<std::byte> to_bytes() const {
        std::vector<std::byte> bytes(byte_size());
        store_bytes(bytes.data());
        return bytes;
    }

    [[nodiscard]] std::int32_t get_precision() const noexcept;

    void pow(std::int32_t exp);

    void multiply(const big_integer &other, big_integer &res) const;

    void divide(const big_integer &divisor, big_integer &res) const;

    void divide(const big_integer &divisor, big_integer &res, big_integer &rem) const;

    void add(const big_integer &other, big_integer &res) const;

    void subtract(const big_integer &other, big_integer &res) const;

    void add(std::uint64_t x);

    [[nodiscard]] int compare(const big_integer &other, bool ignore_sign = false) const;

    [[nodiscard]] std::int64_t to_int64() const;

    [[nodiscard]] bool is_negative() const noexcept { return m_mpi.is_negative(); }

    [[nodiscard]] bool is_zero() const noexcept { return m_mpi.is_zero(); }

    [[nodiscard]] bool is_positive() const noexcept { return m_mpi.is_positive(); }

    void negate() { m_mpi.negate(); }

    [[nodiscard]] std::string to_string() const;

    friend std::ostream &operator<<(std::ostream &os, const big_integer &val);

    friend std::istream &operator>>(std::istream &is, big_integer &val);

    static void get_power_of_ten(std::int32_t pow, big_integer &res);

    friend void swap(big_integer &lhs, big_integer &rhs);
 
private:
    [[nodiscard]] std::uint32_t magnitude_bit_length() const noexcept;

    void divide(const big_integer &divisor, big_integer &res, big_integer *rem) const;

    void from_binary(const std::uint8_t *data, std::size_t size, bool negative = false);

    mutable mpi_t m_mpi;
};

inline bool operator==(const big_integer &lhs, const big_integer &rhs) noexcept {
    return lhs.compare(rhs) == 0;
}

inline bool operator!=(const big_integer &lhs, const big_integer &rhs) noexcept {
    return lhs.compare(rhs) != 0;
}

inline bool operator<(const big_integer &lhs, const big_integer &rhs) noexcept {
    return lhs.compare(rhs) < 0;
}

inline bool operator<=(const big_integer &lhs, const big_integer &rhs) noexcept {
    return lhs.compare(rhs) <= 0;
}

inline bool operator>(const big_integer &lhs, const big_integer &rhs) noexcept {
    return lhs.compare(rhs) > 0;
}

inline bool operator>=(const big_integer &lhs, const big_integer &rhs) noexcept {
    return lhs.compare(rhs) >= 0;
}

inline big_integer operator+(const big_integer &lhs, const big_integer &rhs) noexcept {
    big_integer res;
    lhs.add(rhs, res);
    return res;
}

inline big_integer operator-(const big_integer &lhs, const big_integer &rhs) noexcept {
    big_integer res;
    lhs.subtract(rhs, res);
    return res;
}

inline big_integer operator*(const big_integer &lhs, const big_integer &rhs) noexcept {
    big_integer res;
    lhs.multiply(rhs, res);
    return res;
}

inline big_integer operator/(const big_integer &lhs, const big_integer &rhs) noexcept {
    big_integer res;
    lhs.divide(rhs, res);
    return res;
}

inline big_integer operator%(const big_integer &lhs, const big_integer &rhs) noexcept {
    big_integer res;
    big_integer rem;
    lhs.divide(rhs, res, rem);
    return rem;
}
 
} // namespace ignite