gmp.cpp

 
#include "delpi/libs/gmp.h"
 
#include <vector>
 
namespace {
size_t gmpz_hash(const mpz_t val) {
  size_t hash = 0;
  for (int i = 0, n = mpz_size(val); i < n; ++i) {
    const mp_limb_t limb = mpz_getlimbn(val, i);
    hash = hash * 2;
    hash = hash ^ limb;
  }
  return hash;
}
}  // namespace

size_t std::hash<mpq_class>::operator()(const mpq_class &val) const noexcept {
  const size_t numeratorHash = gmpz_hash(val.get_num_mpz_t());
  const size_t denominatorHash = gmpz_hash(val.get_den_mpz_t());
  return numeratorHash ^ denominatorHash;
}
 
namespace delpi {
 
std::strong_ordering operator<=>(const mpq_class &lhs, const mpq_t &rhs) {
  const mpq_class &rhs_class = gmp::ToMpqClass(rhs);
  return lhs < rhs_class   ? std::strong_ordering::less
         : lhs > rhs_class ? std::strong_ordering::greater
                           : std::strong_ordering::equal;
}
std::strong_ordering operator<=>(const mpq_t &lhs, const mpq_class &rhs) {
  const mpq_class &lhs_class = gmp::ToMpqClass(lhs);
  return lhs_class < rhs   ? std::strong_ordering::less
         : lhs_class > rhs ? std::strong_ordering::greater
                           : std::strong_ordering::equal;
}
 
namespace gmp {
 
std::vector<mpq_class> ToMpqVector(const mpq_t *const x, const int size) {
  std::vector<mpq_class> result{};
  result.reserve(size);
  for (int i = 0; i < size; i++) result.emplace_back(x[i]);
  return result;
}
 
mpz_class floor(const mpq_class &val) {
  // This rounds towards zero
  mpz_class t{val};
  if (t == val || val > 0) {
    return t;
  } else {
    // val is negative and non-integer, so it was rounded upwards
    return t - 1;
  }
}
 
mpz_class ceil(const mpq_class &val) {
  // This rounds towards zero
  mpz_class t{val};
  if (t == val || val < 0) {
    return t;
  } else {
    // val is positive and non-integer, so it was rounded downwards
    return t + 1;
  }
}
 
}  // namespace gmp
 
}  // namespace delpi