int128_t.h

Go to the documentation of this file.

// =========================================================================================
// This int128 implementtaion got
 
// =========================================================================================
#pragma once
 
#include <cstdint>
#include <functional>
#include <stdexcept>
#include <string>
 
#include "api.h"
 
namespace kuzu {
namespace common {
 
struct KUZU_API int128_t;
 
// System representation for int128_t.
struct int128_t {
 uint64_t low;
 int64_t high;
 
 int128_t() = default;
 int128_t(int64_t value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(int32_t value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(int16_t value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(int8_t value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(uint64_t value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(uint32_t value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(uint16_t value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(uint8_t value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(double value); // NOLINT: Allow implicit conversion from numeric values
 int128_t(float value); // NOLINT: Allow implicit conversion from numeric values
 
 constexpr int128_t(uint64_t low, int64_t high) : low(low), high(high) {}
 
 constexpr int128_t(const int128_t&) = default;
 constexpr int128_t(int128_t&&) = default;
 int128_t& operator=(const int128_t&) = default;
 int128_t& operator=(int128_t&&) = default;
 
 int128_t operator-() const;
 
 // inplace arithmetic operators
 int128_t& operator+=(const int128_t& rhs);
 int128_t& operator*=(const int128_t& rhs);
 int128_t& operator|=(const int128_t& rhs);
 int128_t& operator&=(const int128_t& rhs);
 
 // cast operators
 explicit operator int64_t() const;
 explicit operator int32_t() const;
 explicit operator int16_t() const;
 explicit operator int8_t() const;
 explicit operator uint64_t() const;
 explicit operator uint32_t() const;
 explicit operator uint16_t() const;
 explicit operator uint8_t() const;
 explicit operator double() const;
 explicit operator float() const;
};
 
// arithmetic operators
KUZU_API int128_t operator+(const int128_t& lhs, const int128_t& rhs);
KUZU_API int128_t operator-(const int128_t& lhs, const int128_t& rhs);
KUZU_API int128_t operator*(const int128_t& lhs, const int128_t& rhs);
KUZU_API int128_t operator/(const int128_t& lhs, const int128_t& rhs);
KUZU_API int128_t operator%(const int128_t& lhs, const int128_t& rhs);
KUZU_API int128_t operator^(const int128_t& lhs, const int128_t& rhs);
KUZU_API int128_t operator&(const int128_t& lhs, const int128_t& rhs);
KUZU_API int128_t operator~(const int128_t& val);
KUZU_API int128_t operator|(const int128_t& lhs, const int128_t& rhs);
KUZU_API int128_t operator<<(const int128_t& lhs, int amount);
KUZU_API int128_t operator>>(const int128_t& lhs, int amount);
 
// comparison operators
KUZU_API bool operator==(const int128_t& lhs, const int128_t& rhs);
KUZU_API bool operator!=(const int128_t& lhs, const int128_t& rhs);
KUZU_API bool operator>(const int128_t& lhs, const int128_t& rhs);
KUZU_API bool operator>=(const int128_t& lhs, const int128_t& rhs);
KUZU_API bool operator<(const int128_t& lhs, const int128_t& rhs);
KUZU_API bool operator<=(const int128_t& lhs, const int128_t& rhs);
 
class Int128_t {
public:
 static std::string ToString(int128_t input);
 
 template<class T>
 static bool tryCast(int128_t input, T& result);
 
 template<class T>
 static T Cast(int128_t input) {
 T result;
 tryCast(input, result);
 return result;
 }
 
 template<class T>
 static bool tryCastTo(T value, int128_t& result);
 
 template<class T>
 static int128_t castTo(T value) {
 int128_t result;
 if (!tryCastTo(value, result)) {
 throw std::overflow_error("INT128 is out of range");
 }
 return result;
 }
 
 // negate
 static void negateInPlace(int128_t& input) {
 if (input.high == INT64_MIN && input.low == 0) {
 throw std::overflow_error("INT128 is out of range: cannot negate INT128_MIN");
 }
 input.low = UINT64_MAX + 1 - input.low;
 input.high = -input.high - 1 + (input.low == 0);
 }
 
 static int128_t negate(int128_t input) {
 negateInPlace(input);
 return input;
 }
 
 static bool tryMultiply(int128_t lhs, int128_t rhs, int128_t& result);
 
 static int128_t Add(int128_t lhs, int128_t rhs);
 static int128_t Sub(int128_t lhs, int128_t rhs);
 static int128_t Mul(int128_t lhs, int128_t rhs);
 static int128_t Div(int128_t lhs, int128_t rhs);
 static int128_t Mod(int128_t lhs, int128_t rhs);
 static int128_t Xor(int128_t lhs, int128_t rhs);
 static int128_t LeftShift(int128_t lhs, int amount);
 static int128_t RightShift(int128_t lhs, int amount);
 static int128_t BinaryAnd(int128_t lhs, int128_t rhs);
 static int128_t BinaryOr(int128_t lhs, int128_t rhs);
 static int128_t BinaryNot(int128_t val);
 
 static int128_t divMod(int128_t lhs, int128_t rhs, int128_t& remainder);
 static int128_t divModPositive(int128_t lhs, uint64_t rhs, uint64_t& remainder);
 
 static bool addInPlace(int128_t& lhs, int128_t rhs);
 static bool subInPlace(int128_t& lhs, int128_t rhs);
 
 // comparison operators
 static bool Equals(int128_t lhs, int128_t rhs) {
 return lhs.low == rhs.low && lhs.high == rhs.high;
 }
 
 static bool notEquals(int128_t lhs, int128_t rhs) {
 return lhs.low != rhs.low || lhs.high != rhs.high;
 }
 
 static bool greaterThan(int128_t lhs, int128_t rhs) {
 return (lhs.high > rhs.high) || (lhs.high == rhs.high && lhs.low > rhs.low);
 }
 
 static bool greaterThanOrEquals(int128_t lhs, int128_t rhs) {
 return (lhs.high > rhs.high) || (lhs.high == rhs.high && lhs.low >= rhs.low);
 }
 
 static bool lessThan(int128_t lhs, int128_t rhs) {
 return (lhs.high < rhs.high) || (lhs.high == rhs.high && lhs.low < rhs.low);
 }
 
 static bool lessThanOrEquals(int128_t lhs, int128_t rhs) {
 return (lhs.high < rhs.high) || (lhs.high == rhs.high && lhs.low <= rhs.low);
 }
 static const int128_t powerOf10[40];
};
 
template<>
bool Int128_t::tryCast(int128_t input, int8_t& result);
template<>
bool Int128_t::tryCast(int128_t input, int16_t& result);
template<>
bool Int128_t::tryCast(int128_t input, int32_t& result);
template<>
bool Int128_t::tryCast(int128_t input, int64_t& result);
template<>
bool Int128_t::tryCast(int128_t input, uint8_t& result);
template<>
bool Int128_t::tryCast(int128_t input, uint16_t& result);
template<>
bool Int128_t::tryCast(int128_t input, uint32_t& result);
template<>
bool Int128_t::tryCast(int128_t input, uint64_t& result);
template<>
bool Int128_t::tryCast(int128_t input, float& result);
template<>
bool Int128_t::tryCast(int128_t input, double& result);
template<>
bool Int128_t::tryCast(int128_t input, long double& result);
 
template<>
bool Int128_t::tryCastTo(int8_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(int16_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(int32_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(int64_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(uint8_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(uint16_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(uint32_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(uint64_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(int128_t value, int128_t& result);
template<>
bool Int128_t::tryCastTo(float value, int128_t& result);
template<>
bool Int128_t::tryCastTo(double value, int128_t& result);
template<>
bool Int128_t::tryCastTo(long double value, int128_t& result);
 
// TODO: const char to int128
 
} // namespace common
} // namespace kuzu
 
template<>
struct std::hash<kuzu::common::int128_t> {
 std::size_t operator()(const kuzu::common::int128_t& v) const noexcept;
};