big_decimal.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 "big_integer.h"
 
#include <cassert>
#include <cctype>
#include <cstdint>
#include <iostream>
#include <sstream>
 
namespace ignite {

class big_decimal {
public:
    // Default
    big_decimal() = default;

    big_decimal(const std::int8_t *mag, std::int32_t len, std::int16_t scale, std::int8_t sign, bool big_endian = true)
        : m_scale(std::int16_t(scale & 0x7FFF))
        , m_magnitude(mag, len, sign, big_endian) {}

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

    explicit big_decimal(int64_t val)
        : m_magnitude(val) {}

    big_decimal(int64_t val, int16_t scale)
        : m_scale(scale)
        , m_magnitude(val) {}

    big_decimal(const big_integer &val, int16_t scale)
        : m_scale(scale)
        , m_magnitude(val) {}

    big_decimal(big_integer &&val, int16_t scale)
        : m_scale(scale)
        , m_magnitude(std::forward<big_integer>(val)) {}

    explicit big_decimal(const char *val, int32_t len)
        : m_magnitude(0) {
        assign_string(val, len);
    }

    explicit big_decimal(const std::string &val)
        : m_magnitude(0) {
        assign_string(val);
    }

    static big_decimal from_double(double val) {
        big_decimal res;
        res.assign_double(val);
        return res;
    }

    [[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;
    }

    explicit operator double() const { return to_double(); }

    explicit operator int64_t() const { return to_int64(); }

    [[nodiscard]] double to_double() const {
        std::stringstream stream;
        stream << *this;
 
        double result;
        stream >> result;
        return result;
    }

    [[nodiscard]] int64_t to_int64() const {
        if (m_scale == 0) {
            return m_magnitude.to_int64();
        }
 
        big_decimal zero_scaled;
 
        set_scale(0, zero_scaled);
 
        return zero_scaled.m_magnitude.to_int64();
    }

    [[nodiscard]] std::int16_t get_scale() const noexcept { return m_scale; }

    void set_scale(std::int16_t new_scale, big_decimal &res) const;

    [[nodiscard]] std::int32_t get_precision() const noexcept { return m_magnitude.get_precision(); }

    [[nodiscard]] const big_integer &get_unscaled_value() const noexcept { return m_magnitude; }

    friend void swap(big_decimal &lhs, big_decimal &rhs) {
        using std::swap;
 
        swap(lhs.m_scale, rhs.m_scale);
        swap(lhs.m_magnitude, rhs.m_magnitude);
    }

    void assign_string(const std::string &val) { assign_string(val.data(), static_cast<int32_t>(val.size())); }

    void assign_string(const char *val, int32_t len) {
        std::stringstream converter;
 
        converter.write(val, len);
 
        converter >> *this;
    }

    void assign_int64(int64_t val) {
        m_magnitude.assign_int64(val);
 
        m_scale = 0;
    }

    void assign_double(double val) {
        std::stringstream converter;
 
        converter.precision(16);
 
        converter << val;
        converter >> *this;
    }

    void assign_uint64(uint64_t val) {
        m_magnitude.assign_uint64(val);
 
        m_scale = 0;
    }

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

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

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

    void divide(const big_decimal &other, big_decimal &res) const;

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

    [[nodiscard]] int compare(const big_decimal &other) const;

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

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

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

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

    friend std::istream &operator>>(std::istream &is, big_decimal &val);
 
private:
    std::int16_t m_scale = 0;

    big_integer m_magnitude;
};

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

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

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

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

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

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

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

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

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

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