gmp.h

#pragma once
 
#include <gmp.h>    // IWYU pragma: export
#include <gmpxx.h>  // IWYU pragma: export
 
#include <cctype>
#include <cmath>
#include <compare>  // NOLINT (build/include_order): Standard library.
#include <cstring>
#include <string>
#include <string_view>
#include <vector>
 
template <>
struct std::hash<mpq_class> {
  size_t operator()(const mpq_class &val) const noexcept;
};
 
namespace delpi {
 
std::strong_ordering operator<=>(const mpq_class &lhs, const mpq_t &rhs);
std::strong_ordering operator<=>(const mpq_t &lhs, const mpq_class &rhs);
 
namespace gmp {
 
inline const mpq_class infinity{mpz_class{0}, 0};
 
inline std::size_t complexity(const mpq_class &val) {
  return mpz_size(val.get_num().get_mpz_t()) + mpz_size(val.get_den().get_mpz_t());
}

std::vector<mpq_class> ToMpqVector(const mpq_t *x, int size);

mpz_class floor(const mpq_class &val);
mpz_class ceil(const mpq_class &val);
inline bool sign(const mpq_class &val) { return val.get_num() >= 0; }
inline bool IsInfinity(const mpq_class &val) { return mpz_sgn(val.get_den().get_mpz_t()) == 0; }

inline const mpq_t &ToMpq(const mpq_class &cla) { return *reinterpret_cast<const mpq_t *>(cla.get_mpq_t()); }
 
inline mpq_t &ToMpq(mpq_class &cla) { return *reinterpret_cast<mpq_t *>(cla.get_mpq_t()); }  // NOLINT

inline const mpq_class &ToMpqClass(const mpq_t &mpq) { return reinterpret_cast<const mpq_class &>(mpq); }

inline mpq_class &ToMpqClass(mpq_t &mpq) { return reinterpret_cast<mpq_class &>(mpq); }  // NOLINT

inline bool IsDigitOrSign(const char c) { return std::isdigit(c) || c == '+' || c == '-'; }

inline mpq_class StringToMpq(std::string_view input) {
  if (input.empty()) return mpq_class{0};
  // Remove leading + and - sign
  const bool is_negative = input[0] == '-';
  if (is_negative || input[0] == '+') input.remove_prefix(1);
  if (input == "inf") return {is_negative ? -1e100 : 1e100};
 
  constexpr std::size_t max_size = 1 << 10;
  char str_buffer[max_size + 1];
 
  const std::size_t buffer_size = std::min(input.size(), max_size);
  std::memcpy(str_buffer, input.data(), buffer_size);
  str_buffer[buffer_size] = '\0';
  std::string_view str{str_buffer, buffer_size};
 
  // case 1: string is given in integer format
  const size_t symbol_pos = str.find_first_of("/.Ee");
  if (symbol_pos == std::string::npos) {
    const size_t start_pos = str.find_first_not_of('0');
    if (start_pos == std::string_view::npos) return {0};
    str.remove_prefix(start_pos);
    return is_negative ? -mpq_class{str.data()} : mpq_class{str.data()};
  }
 
  // case 2: string is given in nom/denom format
  if (str[symbol_pos] == '/') {
    mpq_class res{str.data()};
    res.canonicalize();
    return is_negative ? -res : res;
  }
 
  const size_t e_pos = str[symbol_pos] == 'e' || str[symbol_pos] == 'E' ? symbol_pos : str.find_first_of("Ee");
  mpz_class mult{is_negative ? -1 : 1};
  bool is_exp_positive = true;
 
  // case 3a: string is given as base-10 decimal number (e)
  if (e_pos != std::string::npos) {
    const long exponent = std::stol(str.data() + e_pos + 1);  // NOLINT(runtime/int)
    is_exp_positive = exponent >= 0;
    mult = 10;
    mpz_pow_ui(mult.get_mpz_t(), mult.get_mpz_t(), std::abs(exponent));
    if (is_negative) mult = -mult;
    // Remove the exponent
    str = str.substr(0, e_pos);
 
    if (str.empty()) return is_exp_positive ? mpq_class{mult} : is_negative ? mpq_class{-1, -mult} : mpq_class{1, mult};
  }
 
  const size_t len = str.length();
 
  // case 3b: string does not contain a . , only an exponent E
  if (str[symbol_pos] == 'e' || str[symbol_pos] == 'E') {
    str_buffer[len] = '\0';
    const mpq_class res{str.data(), 10};
    return is_exp_positive ? mpq_class{res * mult} : mpq_class{res / mult};
  }
 
  const size_t &dot_pos = symbol_pos;
 
  // case 3c: string contains a .
  size_t start_pos = str.find_first_not_of('0');
  size_t digits;
 
  // case 4a: string starts with a . or the numbers before the . are all 0
  if (start_pos == dot_pos) {
    start_pos = str.find_first_not_of('0', dot_pos + 1);
    // case 5: string contains only a .
    if (start_pos == std::string_view::npos) {
      return {0};
    } else {
      digits = len - start_pos;
    }
  } else {  // case 4b: string does not start with a . and the numbers before the . are not all 0
    digits = len - start_pos - 1;
  }
 
  const size_t n_decimals = len - dot_pos - 1;
  char str_number[max_size * 2 + 4];
 
  if (digits > n_decimals) {
    memcpy(str_number, str.data() + start_pos, digits - n_decimals);
    memcpy(str_number + dot_pos, str.data() + dot_pos + 1, n_decimals);
  } else {
    memcpy(str_number, str.data() + start_pos, n_decimals);
  }
 
  str_number[digits] = '/';
  str_number[digits + 1] = '1';
  memset(str_number + digits + 2, '0', n_decimals);
  str_number[digits + 2 + n_decimals] = '\0';
 
  mpq_class res{str_number, 10};
  res.canonicalize();
  return is_exp_positive ? mpq_class{res * mult} : res / mult;
}
 
}  // namespace gmp
 
}  // namespace delpi
 
#ifdef DELPI_INCLUDE_FMT
 
#include "delpi/util/logging.h"
 
OSTREAM_FORMATTER(mpq_class)
 
#endif