soq.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <gmp.h>
 
#include "adapter128.h"
#include "dbc.h"
#include "helper.h"
#include "error.h"
#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_), 10);
    const size_t den_size = mpz_sizeinbase(mpq_denref(q_), 10);
    // +3 for opional '-' and '/' and '\0'
    return num_size + den_size + 3;
  }
 
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_) );
    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);
  }
 
  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 ) {
    mpq_init( q_ );
 
    if( p_den == 0 )
      opErrExit( undefined );    // IDEA: how to handle the problem without an exit() in the ctor?
    __int128_to_mpz_t( mpq_numref( q_ ), p_num );
    __int128_to_mpz_t( mpq_denref( q_ ), p_den );
    mpq_canonicalize( q_ );
 
    DBC_INV_CTOR(SOQ);
  }
 
  ~SOQ() {
    DBC_INV;
 
    mpq_clear( q_ );
  }
 
public: /* virtual */
  [[nodiscard]] SOQ * dup() const override { return new SOQ( q_ ); }
 
  std::string opequal() const override {
    char * buffer = new char[ str_length() ];
    mpq_get_str( buffer, 10, q_ );
    std::string str( buffer );
    delete[] buffer;
    return str;
  }
 
  OTCode ot() const override { return OTCode::Q; }
 
  std::string type() const override { return "rationaltype"; }
 
  bool equal( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOQ*>( p_other );
    return o ?  mpq_equal( q_, o->q_) : false;
  }
 
  bool gt( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOQ*>( p_other );
    if( o == nullptr )
      opErrExit( typecheck);
    return mpq_cmp( q_, o->q_) > 0;
  }
 
  bool ge( const SO * p_other ) const override {
    auto o = dynamic_cast<const SOQ*>( p_other );
    if( o == nullptr )
      opErrExit( typecheck);
    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;
  }
 
  bool getComponents( __int128 & p_num, __int128 & p_den ) const {
    if( ! mpz_t_to___int128( p_num, mpq_numref( q_ ) ) )
      return false;
    if( ! mpz_t_to___int128( p_den, mpq_denref( q_ ) ) )
      return false;
    return true;
  }
 
public: /* other */
  bool isunitfraction() const {
    return mpz_cmp_ui( mpq_numref(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 ) {
    if( mpq_set_str( q_, p_str.c_str(), 10 ) != 0 )
      return false;
    if( mpz_sgn( mpq_denref( q_ ) ) == 0 )
      return false;
    mpq_canonicalize( q_ );
 
    DBC_INV;
    return true;
  }
 
  void abs() {
    mpq_abs( q_, q_ );
 
    DBC_INV;
  }
 
  void neg() {
    mpq_neg( q_, q_ );
 
    DBC_INV;
  }
 
  void reciprocal() {
    if( mpz_sgn( mpq_numref( q_ ) ) == 0 )
      opErrExit( undefinedresult );
    mpq_inv( q_, q_ );
 
    DBC_INV;
  }
 
  __float128 flt128() const;
};