soq.h

Go to the documentation of this file.

 
#pragma once
 
// Inc Library
#include <string>
#include <gmp.h>
 
// Inc HAA
#include "adapter128.h"
#include "dbc.h"
#include "helper.h"
#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_), 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_) );
    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( 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_ );
 
    __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() 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 {
    char * buffer = new char[ str_length() ];
    mpq_get_str( buffer, BASE10, 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( OpError & p_ec, const SO * p_other ) const override {
    auto o = dynamic_cast<const SOQ*>( p_other );
    if( o == nullptr ) {
      p_ec = typecheck;
      return false;
    }
    p_ec = success;
    return mpq_cmp( q_, o->q_) > 0;
  }
 
 
  bool ge( OpError & p_ec, const SO * p_other ) const override {
    auto o = dynamic_cast<const SOQ*>( p_other );
    if( o == nullptr ) {
      p_ec = typecheck;
      return false;
    }
    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 {
    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;
  }
 
 
  bool iszero() const {
    return mpz_cmp_ui( mpq_numref(q_), 0u ) == 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( const std::string & p_str ) {
    if( mpq_set_str( q_, p_str.c_str(), BASE10 ) != 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( 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() const;
 
};