libgmp.h

 
#pragma once
 
#include <gmp.h>    // IWYU pragma: export
#include <gmpxx.h>  // IWYU pragma: export
 
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstring>
#include <string>
#include <string_view>
 
namespace std {
 
template <>
struct hash<mpq_class> {
  size_t operator()(const mpq_class &val) const;
};
}  // namespace std
 
namespace dlinear {
 
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 {
 
mpz_class floor(const mpq_class &val);
mpz_class ceil(const mpq_class &val);
 
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(char c) { return std::isdigit(c) || c == '+' || c == '-'; }
 
inline mpq_class StringToMpq(std::string_view str) {
  // Remove leading + and - sign
  const bool is_negative = str[0] == '-';
  if (is_negative || str[0] == '+') str.remove_prefix(1);
  if (str == "inf") return {1e100};
  if (str == "-inf") return {-1e100};
 
  // 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', str[0] == '+' ? 1 : 0);
    if (start_pos == std::string_view::npos) return {0};
    //    DLINEAR_ASSERT_FMT(std::all_of(str.cbegin() + start_pos, str.cend(), IsDigitOrSign), "Invalid number: {}",
    //    str);
    return is_negative ? -mpq_class{str.data() + start_pos} : mpq_class{str.data() + start_pos};
  }
 
  // 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') {
    int plus_pos = str[0] == '+' ? 1 : 0;
    //    DLINEAR_ASSERT_FMT(std::all_of(str.cbegin() + plus_pos, str.cend(), IsDigitOrSign), "Invalid number: {}",
    //    str);
 
    char *const str_number = new char[len - plus_pos + 1];
    memcpy(str_number, str.data() + plus_pos, len - plus_pos);
    str_number[len - plus_pos] = '\0';
    mpq_class res{str_number, 10};
    delete[] str_number;
    return 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;
  //  DLINEAR_ASSERT_FMT(std::all_of(str.begin() + start_pos, str.begin() + dot_pos, IsDigitOrSign),
  //                     "Invalid number: {}", str);
  //  DLINEAR_ASSERT_FMT(std::all_of(str.begin() + dot_pos + 1, str.cend(), IsDigitOrSign), "Invalid number: {}",
  //  str);
  char *const str_number = new char[digits + n_decimals + 3];
 
  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};
  delete[] str_number;
  res.canonicalize();
  return is_exp_positive ? mpq_class{res * mult} : res / mult;
}
 
}  // namespace gmp
 
}  // namespace dlinear
 
#ifdef DLINEAR_INCLUDE_FMT
 
#include "dlinear/util/logging.h"
 
OSTREAM_FORMATTER(mpq_class)
 
#endif