multi-precision.h

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// Licensed 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.

#ifndef IMPALA_RUNTIME_MULTI_PRECISION_H
#define IMPALA_RUNTIME_MULTI_PRECISION_H


#include <boost/version.hpp>
#if BOOST_VERSION < 105000
#define BOOST_NOEXCEPT
#define BOOST_NOEXCEPT_IF(Predicate)
#define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))

#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_HDR_ARRAY
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES

#include "boost_multiprecision/cpp_int.hpp"
#include "boost_multiprecision/cpp_dec_float.hpp"

#else
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif

#include <limits>

namespace impala {

typedef __int128_t int128_t;

typedef boost::multiprecision::number<
    boost::multiprecision::cpp_int_backend<256, 256,
    boost::multiprecision::signed_magnitude,
    boost::multiprecision::unchecked, void> > int256_t;

inline int256_t ConvertToInt256(const int128_t& x) {
  if (x < 0) {
    uint64_t hi = static_cast<uint64_t>(-x >> 64);
    uint64_t lo = static_cast<uint64_t>(-x);
    int256_t v = hi;
    v <<= 64;
    v |= lo;
    return -v;
  } else {
    uint64_t hi = static_cast<uint64_t>(x >> 64);
    uint64_t lo = static_cast<uint64_t>(x);
    int256_t v = hi;
    v <<= 64;
    v |= lo;
    return v;
  }
}

inline int128_t ConvertToInt128(int256_t x, int128_t max_value, bool* overflow) {
  bool negative = false;
  if (x < 0) {
    x = -x;
    negative = true;
  }

  uint64_t base = std::numeric_limits<int64_t>::max();
  int128_t result = 0;
  int128_t scale = 1;
  while (x != 0) {
    uint64_t v = (x % base).convert_to<uint64_t>();
    x /= base;
    *overflow |= (v > max_value / scale);
    int128_t n = v * scale;
    *overflow |= (result > max_value - n);
    result += n;
    scale *= base;
  }
  return negative ? -result : result;
}

inline int128_t abs(const int128_t& x) { return (x < 0) ? -x : x; }

inline uint64_t HighBits(int128_t x) {
  return x >> 64;
}
inline uint64_t LowBits(int128_t x) {
  return x & 0xffffffffffffffff;
}

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

}

#endif