/Users/mourrain/Devel/mmx/realroot/include/realroot/scalar_rational.hpp

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of realroot software.         *
*      (C) B. Mourrain, GALAAD, INRIA                                *
**********************************************************************
History: 
**********************************************************************/
#ifndef _SCL_MPQ_H_
#define _SCL_MPQ_H_
//----------------------------------------------------------------------
#include <string>
#include <iostream>
#include <realroot/scalar.hpp>
//======================================================================
namespace mmx {
//----------------------------------------------------------------------
typedef MP_INT  MPZ;
typedef MP_RAT  MPQ;
//----------------------------------------------------------------------
std::ostream& operator << (std::ostream& os, const scalar<MPQ>& b);
//----------------------------------------------------------------------
template<> inline
void scalar<MPQ>::init ( )                   {mpq_init(&rep());}
//------------------- scalar<T> (...) -------------------------------------
template<> inline
scalar<MPQ>::scalar ( )                    {mpq_init(&rep());}
//----------------------------------------------------------------------
template<> inline scalar<MPQ>::~scalar ( )   {mpq_clear(&rep());}
//----------------------------------------------------------------------
template<> inline
scalar<MPQ>::scalar (int si)               
     {mpq_init(&rep());mpq_set_si(&rep(),si,1);}
//----------------------------------------------------------------------
template<> inline
scalar<MPQ>::scalar (unsigned si)               
     {mpq_init(&rep());mpq_set_ui(&rep(),si,1);}
//----------------------------------------------------------------------
template<> inline
scalar<MPQ>::scalar (const char *string, unsigned int base)
{
  MP_INT tmp;
  mpz_init_set_str(&tmp, string, base);
  mpq_init(&rep());
  mpq_set_z(&rep(),&tmp);      
}
//----------------------------------------------------------------------
template<> inline
scalar<MPQ>::scalar (signed long int sl)   
     {mpq_init(&rep());mpq_set_si(&rep(),sl,1);}
//----------------------------------------------------------------------
template<> inline
scalar<MPQ>::scalar (unsigned long int ul) 
     {mpq_init(&rep());mpq_set_ui(&rep(),ul,1);}
//----------------------------------------------------------------------
template<> inline 
scalar<MPQ>::scalar(const scalar<MPQ>& rhs) 
{
  mpz_init_set(&rep()._mp_num, &rhs.rep()._mp_num); 
  mpz_init_set(&rep()._mp_den, &rhs.rep()._mp_den); 
}
//----------------------------------------------------------------------
template<> inline 
scalar<MPQ>::scalar(double rhs) 
{
  mpq_init(&rep());
  mpq_set_d(&rep(), rhs); 
}
//----------------------------------------------------------------------
template<> inline 
scalar<MPQ>& scalar<MPQ>::operator =  (const scalar<MPQ>& rhs)
{
  // COUNT<MPQ>('=');
  //if (this != &rhs) 
  //mpq_clear(&rep());
  //mpq_init(&rep());
  mpq_set(&rep(), &rhs.rep()); 
  return *this;
}
//----------------------------------------------------------------------
template<> inline 
bool scalar<MPQ>::operator == (const scalar<MPQ>& rhs) const
{
  return mpq_cmp(&rep(), &rhs.rep()) == 0;
}

template<> inline 
bool scalar<MPQ>::operator == (long sl) const {
  assert(sl>0);
  return mpq_cmp_ui(&rep(), sl, 1) == 0;
  
}

template<> inline 
bool scalar<MPQ>::operator == (int si) const {
  return mpq_cmp_ui(&rep(), (long) si, 1) == 0;
}

template<> inline 
bool scalar<MPQ>::operator == (unsigned long ul) const
{
  return mpq_cmp_ui(&rep(), ul, 1) == 0;
}

// != ------------------------------------------------------------------
template<> inline 
bool scalar<MPQ>::operator != (const scalar<MPQ>& rhs) const
{
  return mpq_cmp(&rep(), &rhs.rep()) != 0;
}

template<> inline 
bool scalar<MPQ>::operator != (long sl) const {
  assert(sl>=0);
  return mpq_cmp_ui(&rep(), sl,1) != 0;
}

template<> inline
bool scalar<MPQ>::operator != (int si) const {
  assert(si>=0);
  return mpq_cmp_ui(&rep(), (long) si,1) != 0;
}

template<> inline 
bool scalar<MPQ>::operator != (unsigned long ul) const
{
  return mpq_cmp_ui(&rep(), ul,1) != 0;
}
// > -------------------------------------------------------------------
template<> inline 
bool scalar<MPQ>::operator > (const scalar<MPQ>& rhs) const
{
  return mpq_cmp(&rep(), &rhs.rep()) > 0;
}

template<> inline 
bool scalar<MPQ>::operator > (long sl) const {
  assert(sl>=0);
  return mpq_cmp_ui(&rep(), sl, 1) > 0;
}

template<> inline 
bool scalar<MPQ>::operator > (int si) const {
  assert(si>=0);
  return mpq_cmp_ui(&rep(), (long) si, 1) > 0;
}

template<> inline 
bool scalar<MPQ>::operator > (unsigned long ul) const
{
  return mpq_cmp_ui(&rep(), ul,1) > 0;
}
// <= --------------------------------------------------------------------
template<> inline 
bool scalar<MPQ>::operator >= (const scalar<MPQ>& rhs) const
{
  return mpq_cmp(&rep(), &rhs.rep()) >= 0;
}

template<> inline 
bool scalar<MPQ>::operator >= (long sl) const {
  assert(sl>=0);
  return mpq_cmp_ui(&rep(), sl, 1) >= 0;
}

template<> inline 
bool scalar<MPQ>::operator >= (int si) const
{
  assert(si>=0);
  return mpq_cmp_ui(&rep(), (long) si, 1) >= 0;
}

template<> inline 
bool scalar<MPQ>::operator >= (unsigned long ul) const
{
  return mpq_cmp_ui(&rep(), ul, 1) >= 0;
}

// < -------------------------------------------------------------------
template<> inline 
bool scalar<MPQ>::operator < (const scalar<MPQ>& rhs) const
{
  return mpq_cmp(&rep(), &rhs.rep()) < 0;
}

template<> inline 
bool scalar<MPQ>::operator < (long sl) const {
  return mpq_cmp_ui(&rep(), sl, 1) < 0;
}

template<> inline 
bool scalar<MPQ>::operator < (int si) const
{
  assert(si>=0);
  return mpq_cmp_ui(&rep(), (long) si, 1) < 0;
}

template<> inline 
bool scalar<MPQ>::operator < (unsigned long ul) const
{
  return mpq_cmp_ui(&rep(), ul, 1) < 0;
}

// <= ------------------------------------------------------------------

template<> inline 
bool scalar<MPQ>::operator <= (const scalar<MPQ>& rhs) const
{
  return mpq_cmp(&rep(), &rhs.rep()) <= 0;
}

template<> inline 
bool scalar<MPQ>::operator <= (long sl) const {
  assert(sl>=0);
  return mpq_cmp_ui(&rep(), sl,1) <= 0;
}

template<> inline 
bool scalar<MPQ>::operator <= (int si) const
{
  assert(si>=0);
  return mpq_cmp_ui(&rep(), (long) si, 1) <= 0;
}

template<> inline 
bool scalar<MPQ>::operator <= (unsigned long ul) const
{
  return mpq_cmp_ui(&rep(), ul, 1) <= 0;
}

// = -------------------------------------------------------------------
template<> inline 
scalar<MPQ>&  scalar<MPQ>::operator =  (unsigned long ul)
{
  mpq_set_ui(&rep(), ul, 1); return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator =  (long sl)
{
  mpq_set_si(&rep(), sl, 1);  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator = (int ul)
{
  mpq_set_si(&rep(), ul, 1);  return *this;
}
// += -------------------------------------------------------------------
template<> inline 
scalar<MPQ>& scalar<MPQ>::operator += (const scalar<MPQ>& rhs)
{
  scalar<MPQ> tmp;
  mpq_add(&tmp.rep(), &rep(), &rhs.rep());  
  mpq_swap(&tmp.rep(),&rep());
  //  mpq_canonicalize(&rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator += (unsigned long ul)
{
  mpq_add(&rep(), &rep(), &scalar<MPQ>(ul).rep());
  //  mpq_canonicalize(&rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator += (long sl)
{
  mpq_add(&rep(), &rep(), &scalar<MPQ>(sl).rep());
  //mpq_canonicalize(&rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator += (int ul)
{
  scalar<MPQ> tmp(ul);
  *this += tmp;  
  //mpq_canonicalize(&rep());
  return *this;
}

// -= -------------------------------------------------------------------
template<> inline 
scalar<MPQ>& scalar<MPQ>::operator -= (const scalar<MPQ>& rhs)
{
  mpq_sub(&rep(), &rep(), &rhs.rep()); 
  //mpq_canonicalize(&rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator -= (unsigned long ul)
{
  mpq_sub(&rep(), &rep(), &scalar<MPQ>(ul).rep()); 
  //mpq_canonicalize(&rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator -= (long sl)
{
  mpq_sub(&rep(), &rep(), &scalar<MPQ>(sl).rep());
  //mpq_canonicalize(&rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator -= (int ul)
{
  *this -= scalar<MPQ>(ul); 
  //mpq_canonicalize(&rep());
  return *this;
}
// *= -----------------------------------------------------------------
template<> inline 
scalar<MPQ>& scalar<MPQ>::operator *= (const scalar<MPQ>& rhs)
{
  mpq_mul(&rep(), &rep(), &rhs.rep()); 
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator *= (int ul)
{
  mpq_mul(&rep(), &rep(), &scalar<MPQ>(ul).rep()); 
  return *this;
}
template<> inline 
scalar<MPQ>& scalar<MPQ>::operator *= (unsigned long ul)
{
  mpq_mul(&rep(), &rep(), &scalar<MPQ>(ul).rep()); 
  return *this;
}
template<> inline 
scalar<MPQ>& scalar<MPQ>::operator *= (long sl)
{
  mpq_mul(&rep(), &rep(), &scalar<MPQ>(sl).rep());
  //mpq_canonicalize(&rep());
  return *this; 
}

// /= ------------------------------------------------------------------
template<> inline 
scalar<MPQ>& scalar<MPQ>::operator /= (const scalar<MPQ>& rhs)
{
  mpq_div(&rep(), &rep(), &rhs.rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator /= (unsigned sl)
{
  mpq_div(&rep(), &rep(),  &scalar<MPQ>(sl).rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator /= (int sl)
{
  mpq_div(&rep(), &rep(),  &scalar<MPQ>(sl).rep());
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator /= (unsigned long ul)
{
  mpq_div(&rep(), &rep(), &scalar<MPQ>(ul).rep()); 
  return *this;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::operator /= (long int sl)
{
  
  mpq_div(&rep(), &rep(),  &scalar<MPQ>(sl).rep());
  //mpq_canonicalize(&rep());
  return *this;
}

//======================================================================
// ARITHMETIC OPERATORS
//======================================================================
inline  
scalar<MPQ> operator +(const scalar<MPQ>& a1, const scalar<MPQ>& a2) 
{
  scalar<MPQ> result;
  mpq_add(&result.rep(), &a1.rep(), &a2.rep());
  //mpq_canonicalize(&result.rep());
  return result;
}
//----------------------------------------------------------------------
inline
scalar<MPQ> operator -(const scalar<MPQ>& a1, const scalar<MPQ>& a2) 
{
  scalar<MPQ> result;
  mpq_sub(&result.rep(), &a1.rep(), &a2.rep());
  //mpq_canonicalize(&result.rep());
  return result;
}
inline
scalar<MPQ> operator -(const scalar<MPQ>& a1) 
{
  scalar<MPQ> r;  mpq_neg(&r.rep(), &a1.rep()); return r;
}
//----------------------------------------------------------------------
inline
scalar<MPQ> operator *(const scalar<MPQ>& a1, const scalar<MPQ>& a2) 
{
  //   static 
  scalar<MPQ> result;
  // if(mpq_cmp_ui(&a1.rep(),0ul,1ul) && mpq_cmp_ui(&a2.rep(),0ul,1ul))
  mpq_mul(&result.rep(), &a1.rep(), &a2.rep());
  return result;
}

inline 
scalar<MPQ> operator *(const scalar<MPQ>& a1, const scalar<MPZ>& a2) 
{
  return a1*scalar<MPQ>(a2);
}

inline scalar<MPQ> operator *(const scalar<MPZ>& a1, const scalar<MPQ>& a2) 
{
  return a2*scalar<MPQ>(a1);
}
//--------------------------------------------------------------------
inline
scalar<MPQ> operator *(const scalar<MPQ>& a2, int a1) 
{
  return a2 * scalar<MPQ>(a1);
}

inline
scalar<MPQ> operator *(int a1, const scalar<MPQ>& a2) 
{
  return a2 * scalar<MPQ>(a1);
}

inline
scalar<MPQ> operator /(const scalar<MPQ>& a1, const scalar<MPQ>& a2) 
{
  scalar<MPQ> result;
  mpq_div(&result.rep(), &a1.rep(), &a2.rep());
  return result;
}

inline 
scalar<MPQ> operator /(const scalar<MPQ>& a1, const scalar<MPZ>& a2) 
{
  return a1/scalar<MPQ>(a2);
}
//======================================================================
template<> inline 
void scalar<MPQ>::operator ++ ( )
{
  mpq_add(&rep(), &rep(), &scalar<MPQ>(1).rep());
  //mpq_canonicalize(&rep());
}
//----------------------------------------------------------------------
template<> inline 
void scalar<MPQ>::operator -- ( )
{
  mpq_sub(&rep(), &rep(), &scalar<MPQ>(1).rep());
  //mpq_canonicalize(&rep());
}
//======================================================================
// INPUT OUTPUT
//======================================================================
inline
std::ostream& operator << (std::ostream& os, const scalar<MPQ>& b)
{
  mpq_out_str(stdout, 10, &b.rep());  //MP_INT tmp; //mpz_init(&tmp);
  return os;       
}

inline char* as_charp( const scalar<MPQ>& b) {
  return mpq_get_str(NULL,10,&b.rep());
}

template<class OSTREAM> inline void 
print(OSTREAM& os, const scalar<MPQ>& b) {
  os<<as_charp(b);
}
//----------------------------------------------------------------------
inline
std::istream& operator >> (std::istream& is, scalar<MPQ>& b)
{
  std::string s;is >> s;
  MP_INT tmp;
  mpz_init_set_str(&tmp,s.c_str(), 10);
  mpq_init(&b.rep());
  mpq_set_z(&b.rep(),&tmp);
    return is;          
}
//======================================================================
// SPECIAL FUNCTIONS
//======================================================================
template<> inline void
scalar<MPQ>::abs ( )
{
  if (rep()._mp_num._mp_size < 0) rep()._mp_num._mp_size = - rep()._mp_num._mp_size;
}

template<> inline 
scalar<MPQ>& scalar<MPQ>::negate ( )
{
  rep()._mp_num._mp_size = - rep()._mp_num._mp_size; return *this;
}

inline scalar<MPZ> numerator(const scalar<MPQ>& q)   { scalar<MPZ> r; mpq_get_num(&r.rep(),&q.rep()); return r;}
inline scalar<MPZ> denominator(const scalar<MPQ>& q) { scalar<MPZ> r; mpq_get_den(&r.rep(),&q.rep()); return r;}
inline scalar<MPZ> rfloor (const scalar<MPQ>& q) { scalar<MPZ> r=numerator(q); r/=denominator(q); return r; }
inline scalar<MPZ> rceil  (const scalar<MPQ>& q) { return rfloor(q)+1; }
//-------------------------- compare (...) ------------------------------------
inline int compare (const scalar<MPQ>& b1, const scalar<MPQ>& b2)
{
  return mpq_cmp(&b1.rep(), &b2.rep());
}

inline int compare (const scalar<MPQ>& b, unsigned long ul)
{
  return mpq_cmp_ui(&b.rep(), ul, 1);
}

inline int compare (const scalar<MPQ>& b, long sl)
{
  assert(sl>=0);
  return mpq_cmp_ui(&b.rep(), sl, 1);
}

inline scalar<MPQ> min(const scalar<MPQ>& a1, const scalar<MPQ>& a2) {return (a1<a2?a1:a2);}
inline scalar<MPQ> max(const scalar<MPQ>& a1, const scalar<MPQ>& a2) {return (a1>a2?a1:a2);}

//----------------------------------------------------------------------
inline void convert (scalar<MPQ>& dd, char *s)
{
  mpq_clear(&dd.rep());
  mpq_init(&dd.rep());
  mpz_set_str(mpq_numref(&dd.rep()),s,10);
}
//----------------------------------------------------------------------
inline scalar<MPQ> Size(const scalar<MPQ> & r) { return abs(r); };

namespace let
{
  inline void assign(scalar<MPQ> & x, char *s) { mpq_set_str(&x.rep(), s, 10);}
  inline void assign(scalar<MPQ> & q, double d ) { mpq_set_d(&q.rep(),d); }
  inline void assign(double & d, const scalar<MPQ>& x ) 
  {
    d = mpq_get_d(&x.rep());
  } 
}
//--------------------------------------------------------------------
  
inline double to_double(const scalar<MPQ>& a)   { return mpq_get_d(&a.rep()); }

template<typename T,typename F> struct as_helper;

template<> struct as_helper<double,scalar<MPQ> > { 
  static inline double cv(const scalar<MPQ>& x) {double r; let::assign(r,x); return r;}
};

} //namespace mmx
//======================================================================
#endif // //SCL_MPQ_H