soq.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <string_view>
#include <cstring>
#include <gmp.h>
 
// Inc Pure
#include "conversion.h"
#include "dbc.h"
#include "helper.h"
#include "algo.h"
 
// Inc Medium
#include "error.h"
 
// Inc Rich
#include "so.h"
 
 
class SOQ : public SO {
 
  mpq_t q_{};            
 
 
  size_t str_length() const {
    const size_t num_size = mpz_sizeinbase( mpq_numref(q_), BASE10 );
    const size_t den_size = mpz_sizeinbase( mpq_denref(q_), BASE10 );
    // +3 for an optional '-', a ':' and a '\0'
    return num_size + den_size + 3;
  }
 
 
  bool parse_work( std::string & p_str );
 
protected:
 
#ifndef DBC_IS_VOID
  bool invariant() const noexcept override {     /* LCOV_EXCL_START */
    if( mpz_sgn( mpq_denref( q_ ) ) != 1 )
      return false;
    mpz_t g;
    mpz_init( g );
    mpz_gcd( g, mpq_numref(q_), mpq_denref(q_) );
    const int rv = mpz_cmp_si( g, 1 );
    mpz_clear( g );
    return rv == 0;
  }                                              /* LCOV_EXCL_STOP */
#endif
 
public:
 
  SOQ() {
    mpq_init( q_ );
 
    DBC_INV_CTOR(SOQ);
  }
 
 
  explicit SOQ( std::string & p_s ) {
    DBC_PRE( algo::hasRationalSyntax(p_s) );
 
    (void) parse_work( p_s );
 
    DBC_INV_CTOR(SOQ);
  }
 
 
 
  explicit SOQ( const mpq_t p_q ) {
    mpq_init( q_ );
    mpq_set( q_, p_q );
 
    DBC_INV_CTOR(SOQ);
  }
 
 
  SOQ( const __int128 p_num, const __int128 p_den ) {
    DBC_PRE( p_den != 0 );
 
    mpq_init( q_ );
 
    conversion::__int128_to_mpz_t( mpq_numref( q_ ), p_num );
    conversion::__int128_to_mpz_t( mpq_denref( q_ ), p_den );
    mpq_canonicalize( q_ );
 
    DBC_INV_CTOR(SOQ);
  }
  
 
  ~SOQ() override {
    DBC_INV_CTOR(SOQ);
 
    mpq_clear( q_ );
  }
 
 
  SOQ( const SOQ & ) = delete;
  SOQ( SOQ && ) = delete;
  SOQ & operator=( const SOQ & ) = delete;
  SOQ & operator=( SOQ && ) = delete;
 
public: /* virtual */
 
  [[nodiscard]] SOQ * dup() const override { return new SOQ( q_ ); }
 
 
  std::string opequal() const override;
 
 
  OTCode ot() const override { return OTCode::Q; }
 
 
  std::string_view type() const override { return "rationaltype"; }
 
 
  bool equal( const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != ot() )
      return false;
    const auto o = static_cast<const SOQ *>( p_other );
    return mpq_equal( q_, o->q_);
  }
 
 
  bool gt( OpError & p_ec, const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::Q ) {
      p_ec = typecheck;
      return false;
    }
    const auto o = static_cast<const SOQ *>( p_other );
    p_ec = success;
    return mpq_cmp( q_, o->q_) > 0;
  }
 
 
  bool ge( OpError & p_ec, const SO * p_other ) const override {
    DBC_PRE( p_other != nullptr );
 
    if( p_other->ot() != OTCode::Q ) {
      p_ec = typecheck;
      return false;
    }
    const auto o = static_cast<const SOQ *>( p_other );
    p_ec = success;
    return mpq_cmp( q_, o->q_) >= 0;
  }
 
public: /* accessor */
 
  void getRational( mpq_t p_q ) const {
    mpq_set( p_q, q_ );
  }
 
 
  void setRational( const mpq_t p_q ) {
    mpq_set( q_, p_q );
 
    DBC_INV;
  }
 
 
  void getNumerator( mpz_t p_z ) const {
    mpz_set( p_z, mpq_numref(q_) );
  }
 
 
  void setNumerator( mpz_t p_z ) {
    mpz_set( mpq_numref(q_), p_z );
    mpq_canonicalize( q_ );
 
    DBC_INV;
  }
 
 
  bool getComponents( __int128 & p_num, __int128 & p_den ) const {
    auto [conv1, num] = conversion::mpz_t_to___int128( mpq_numref( q_ ) );
    if( !conv1 )
      return false;
    p_num = num;
    auto [conv2, den] = conversion::mpz_t_to___int128( mpq_denref( q_ ) );
    if( !conv2 )
      return false;
    p_den = den;
    return true;
  }
 
public: /* other */
 
  bool isunitfraction() const {
    return mpz_cmp_ui( mpq_numref(q_), 1u ) == 0;
  }
 
 
  bool isinteger() const {
    return mpz_cmp_ui( mpq_denref(q_), 1u ) == 0;
  }
 
 
  void divqr( mpq_t p_q, mpq_t p_r ) const {
    mpz_set_ui( mpq_denref( p_q ), 1u );                                     // set the denominator of p_q = 1
    mpz_set( mpq_denref( p_r ), mpq_denref( q_ ) );                          // set the denominator of p_r = denominator of q_
    mpz_fdiv_qr( mpq_numref(p_q), mpq_numref(p_r), mpq_numref(q_), mpq_denref(q_) );
  }
 
 
  bool parse( std::string & p_str ) {
    const bool rv = parse_work( p_str );
    if( !rv )
      mpq_set_si( q_, 0, 1 );
 
    DBC_INV;
    return rv;
  }
 
 
  void abs__1() {
    mpq_abs( q_, q_ );
 
    DBC_INV;
  }
 
 
  void neg__1() {
    mpq_neg( q_, q_ );
 
    DBC_INV;
  }
 
 
  void sqr__1() {
    mpz_mul( mpq_numref(q_), mpq_numref(q_), mpq_numref(q_) );
    mpz_mul( mpq_denref(q_), mpq_denref(q_), mpq_denref(q_) );
 
    DBC_INV;
  }
 
 
  void half__1() {
    mpq_div_2exp( q_, q_, 1 );
 
    DBC_INV;
  }
 
 
  void reciprocal__1( OpError & p_ec ) {
    p_ec = success;
    if( mpz_sgn( mpq_numref( q_ ) ) == 0 )
      p_ec = undefinedresult;
    else
      mpq_inv( q_, q_ );
 
    DBC_INV;
  }
 
 
  __float128 float128( OpError & p_ec ) const;
 
};