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

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of ALP software.         *
*      (C) B. Mourrain, GALAAD, INRIA                                *
**********************************************************************
History: 
$Id: scalar_mpf.H,v 1.1.1.1 2006/10/06 08:01:40 trebuche Exp $
**********************************************************************/
#ifndef _SCL_MPF_H_
#define _SCL_MPF_H_
//----------------------------------------------------------------------
#include <string>
#include <iostream>
#include <gmp.h>
#include <realroot/scalar.hpp>
//======================================================================
namespace mmx {
//----------------------------------------------------------------------
typedef __mpf_struct  MPF;
  //unsigned long MPF_PRECISION;
//----------------------------------------------------------------------
//template<> inline shared_object<MPF>::rep::~rep() {mpf_clear(&obj);}
//----------------------------------------------------------------------
template<> inline
void scalar<MPF>::init ( )                   {mpf_init(&rep());}
//------------------- scalar<T> (...) -------------------------------------
template<> inline
scalar<MPF>::scalar ( )                    {
  //  cout<<"default construct "<<endl;
mpf_init(&rep());}
//----------------------------------------------------------------------
template<> inline 
scalar<MPF>::scalar(const scalar<MPF>& rhs) 
{
  //cout<<"const SCl "<<endl;
  mpf_init_set(&rep(),&rhs.rep()); 
}
//----------------------------------------------------------------------
template<> inline 
scalar<MPF>& scalar<MPF>::operator =  (const scalar<MPF>& rhs)
{
  if (this != &rhs) {
    mpf_set(&rep(), &rhs.rep());
  }
  return *this;
}
//----------------------------------------------------------------------
template<> inline
scalar<MPF>::scalar (signed long int sl)   {mpf_init_set_si(&rep(),sl);}
//----------------------------------------------------------------------
template<> inline
scalar<MPF>::scalar (unsigned long int ul) {mpf_init_set_ui(&rep(),ul);}
//----------------------------------------------------------------------
template<> inline
scalar<MPF>::scalar (int si)               {
  // cout<<"init set si "<<endl;
mpf_init_set_si(&rep(), si);}
//----------------------------------------------------------------------
template<> inline
scalar<MPF>::scalar (const char *string, unsigned int base)
{
  if (mpf_init_set_str(&rep(), string, base))
    std::cerr << "scalar<MPF>: The string " << string 
              << " is not a valid number in base " << base << std::endl;
}
template<> inline
scalar<MPF>::scalar (double d)
{
  //cout<<"je passe dans construct double "<<endl;
  mpf_init_set_d(&rep(),d);
}
//----------------------------------------------------------------------
template<> inline scalar<MPF>::~scalar (){mpf_clear(&rep());}
//----------------------------------------------------------------------
template<> inline 
bool scalar<MPF>::operator == (const scalar<MPF>& rhs) const
{
  return mpf_cmp(&rep(), &rhs.rep()) == 0;
}

template<> inline 
bool scalar<MPF>::operator == (long sl) const {
  return mpf_cmp_si(&rep(), sl) == 0;
}

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

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

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

template<> inline 
bool scalar<MPF>::operator != (long sl) const {
  return mpf_cmp_si(&rep(), sl) != 0;
}

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

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

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

template<> inline 
bool scalar<MPF>::operator > (int si) const {
  return mpf_cmp_si(&rep(), (long) si) > 0;
}

template<> inline 
bool scalar<MPF>::operator > (unsigned long ul) const
{
  return mpf_cmp_ui(&rep(), ul) > 0;
}
// <= --------------------------------------------------------------------
template<> inline 
bool scalar<MPF>::operator >= (const scalar<MPF>& rhs) const
{
  return mpf_cmp(&rep(), &rhs.rep()) >= 0;
}

template<> inline 
bool scalar<MPF>::operator >= (long sl) const {
  return mpf_cmp_si(&rep(), sl) >= 0;
}

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

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

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

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

template<> inline 
bool scalar<MPF>::operator < (int si) const
{
  return mpf_cmp_si(&rep(), (long) si) < 0;
}

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

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

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

template<> inline 
bool scalar<MPF>::operator <= (long sl) const {
  return mpf_cmp_si(&rep(), sl) <= 0;
}

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

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

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

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

template<> inline 
scalar<MPF>& scalar<MPF>::operator = (int ul)
{
  mpf_set_si(&rep(), ul);  return *this;
}
// += -------------------------------------------------------------------
template<> inline 
scalar<MPF>& scalar<MPF>::operator += (const scalar<MPF>& rhs)
{
  scalar<MPF> tmp;
  //mpf_init(tmp.&rep());
  mpf_add(&tmp.rep(), &rep(), &rhs.rep());  
  mpf_swap(&tmp.rep(),&rep());
  return *this;

}

template<> inline 
scalar<MPF>& scalar<MPF>::operator += (unsigned long ul)
{
  mpf_add_ui(&rep(), &rep(), ul); return *this;
}

template<> inline 
scalar<MPF>& scalar<MPF>::operator += (long sl)
{
  if (sl >= 0)
    mpf_add_ui(&rep(), &rep(), (unsigned long) sl);
  else
    mpf_sub_ui(&rep(), &rep(), ((unsigned long) -sl));
  return *this;
}

template<> inline 
scalar<MPF>& scalar<MPF>::operator += (int ul)
{
  *this += scalar<MPF>(ul);  return *this;
}

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

template<> inline 
scalar<MPF>& scalar<MPF>::operator -= (unsigned long ul)
{
  mpf_sub_ui(&rep(), &rep(), ul); return *this;
}

template<> inline 
scalar<MPF>& scalar<MPF>::operator -= (long sl)
{
  if (sl >= 0)
    mpf_sub_ui(&rep(), &rep(), (unsigned long) sl);
  else
    mpf_add_ui(&rep(), &rep(), (unsigned long) sl);
  return *this;
}

template<> inline 
scalar<MPF>& scalar<MPF>::operator -= (int ul)
{
  *this -= scalar<MPF>(ul); return *this;
}
// *= -----------------------------------------------------------------
template<> inline 
scalar<MPF>& scalar<MPF>::operator *= (const scalar<MPF>& rhs)
{
  mpf_mul(&rep(), &rep(), &rhs.rep()); return *this;
}
template<> inline 
scalar<MPF>& scalar<MPF>::operator *= (unsigned long ul)
{
  mpf_mul_ui(&rep(), &rep(), ul); return *this;
}
template<> inline 
scalar<MPF>& scalar<MPF>::operator *= (long sl)
{
  if (sl >= 0)
    mpf_mul_ui(&rep(), &rep(), (unsigned long) sl);
  else
    {
      mpf_neg(&rep(),&rep());
      mpf_mul_ui(&rep(), &rep(),(unsigned long)(-sl));
    }
  return *this; 
}
template<> inline 
scalar<MPF>& scalar<MPF>::operator *= (double d)
{
  return *this*=(scalar<MPF>)d;
}

template<> inline 
scalar<MPF>& scalar<MPF>::operator *= (int ul)
{
   if (ul >= 0)
     mpf_mul_ui(&rep(), &rep(), (unsigned long) ul);
   else {
     mpf_mul_ui(&rep(), &rep(), (unsigned long) (-ul));
     mpf_neg(&rep(), &rep());
   }
   return *this;
}
// /= ------------------------------------------------------------------
template<> inline 
scalar<MPF>& scalar<MPF>::operator /= (const scalar<MPF>& rhs)
{
  mpf_div(&rep(), &rep(), &rhs.rep());
  //mpf_divexact(&rep(), &rep(), &rhs.rep()); 
  return *this;
}
template<> inline 
scalar<MPF>& scalar<MPF>::operator /= (unsigned long ul)
{
  mpf_div_ui(&rep(), &rep(), ul); return *this;
}

template<> inline 
scalar<MPF>& scalar<MPF>::operator /= (long sl)
{
  if (sl >= 0)
    mpf_div_ui(&rep(), &rep(), (unsigned long) sl);
  else
    {
      mpf_neg(&rep(),&rep());
      mpf_div_ui(&rep(), &rep(), ((unsigned long) -sl));
    }
  return *this;
}
template<> inline 
scalar<MPF>& scalar<MPF>::operator /= (int sl)
{
  if (sl >= 0)
    mpf_div_ui(&rep(), &rep(), (unsigned long) sl);
  else
    {
      mpf_neg(&rep(),&rep());
      mpf_div_ui(&rep(), &rep(), ((unsigned long) -sl));
    }
  return *this;
}

//======================================================================
// ARITHMETIC OPERATORS
//======================================================================
//  scalar<MPF> operator -(const scalar<MPF>& a1) 
//   {
//     scalar<MPF> result(a1);
//     result*=(-1);
//     return result;
//   }
inline
scalar<MPF> operator +(const scalar<MPF>& a1, const scalar<MPF>& a2) 
{
  scalar<MPF> result;
  mpf_add(&result.rep(), &a1.rep(), &a2.rep());
  return result;
}
//----------------------------------------------------------------------
inline
scalar<MPF> operator -(const scalar<MPF>& a1, const scalar<MPF>& a2) 
{
  scalar<MPF> result;
  mpf_sub(&result.rep(),&a1.rep(), &a2.rep());
  return result;
}

inline
scalar<MPF> operator -(const scalar<MPF>& a1) 
{
  scalar<MPF> r;  mpf_neg(&r.rep(), &a1.rep()); return r;
}
//----------------------------------------------------------------------
inline
scalar<MPF> operator *(const scalar<MPF>& a1, const scalar<MPF>& a2) 
{
  scalar<MPF> result;
  mpf_mul(&result.rep(), &a1.rep(), &a2.rep());
  return result;
}
//----------------------------------------------------------------------
inline
scalar<MPF> operator /(const scalar<MPF>& a1, const scalar<MPF>& a2) 
{
  scalar<MPF> result;
  mpf_div(&result.rep(), &a1.rep(), &a2.rep());
  return result;
}
//======================================================================
template<> inline 
void scalar<MPF>::operator ++ ( )
{
  mpf_add_ui(&rep(), &rep(), 1);
}
//----------------------------------------------------------------------
template<> inline 
void scalar<MPF>::operator -- ( )
{
  mpf_sub_ui(&rep(), &rep(), 1);
}
//======================================================================
inline void convert(scalar<MPF>& n, char *s) 
{
  // printf("%s\n",s);
  mpf_init_set_str(&n.rep(), s, 10);
  //cout<<"apres convert "<<mpf_get_d(n.rep())<<endl;;
}
//======================================================================
// INPUT OUTPUT
//======================================================================
inline
std::ostream& operator << (std::ostream& os, const scalar<MPF>& b)
{
  double temp;
  temp=mpf_get_d(&b.rep());
  os<<temp;
  //mpf_out_str(stdout, 10,16,&b.rep()); 
  return os;
}
//----------------------------------------------------------------------
inline
std::istream& operator >> (std::istream& is, scalar<MPF>& b)
{
  std::string s;is >> s;
  mpf_init_set_str(&b.rep(),s.c_str(), 10);
  return is;
}
//======================================================================
// SPECIAL FUNCTIONS
//======================================================================
inline void Precision(unsigned long l)
{
   mpf_set_default_prec(l);
}
//----------------------------------------------------------------------
inline void Precision( scalar<MPF>& b, unsigned long l)
{
  mpf_set_prec(&b.rep(),l);
}
//======================================================================
template<> inline 
void scalar<MPF>::Div2Exp (unsigned long exponent_of_2)
{
  mpf_div_2exp(&rep(), &rep(), exponent_of_2);
}

template<> inline void
scalar<MPF>::abs ( )
{
  if (mpf_sgn(&rep()) < 0)
    mpf_neg(&rep(),&rep());
}

template<> inline 
scalar<MPF>& scalar<MPF>::negate ( )
{
  mpf_neg(&rep(),&rep());
  //&rep()._mp_size = - &rep()._mp_size; 
  return *this;
}

template<> inline 
void scalar<MPF>::sqrt ( )
{
  mpf_sqrt(&rep(), &rep());
}

//-------------------------- log(...) -----------------------------------
inline size_t log (const scalar<MPF>& b)
{
  return mpf_size(&b.rep());
}
//-------------------------- sign ---------------------------------------------
inline int sign (const scalar<MPF>& b)
{
  return mpf_sgn(&b.rep());
}
//-------------------------- compare (...) ------------------------------------
inline int compare (const scalar<MPF>& b1, const scalar<MPF>& b2)
{
  return mpf_cmp(&b1.rep(), &b2.rep());
}

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

inline int compare (const scalar<MPF>& b, long sl)
{
  return mpf_cmp_si(&b.rep(), sl);
}
//----------------------------------------------------------------------
//  scalar<MPF> & operator =(scalar<MPF> &lhs,double &rhs)
//  {
//    mpf_set_d(lhs.rep(),rhs);
//    return lhs;
//  }
//----------------------------------------------------------------------
inline void assign(double& r, const scalar<MPF>& z ) { r = mpf_get_d(&z.rep()); }; 
inline void assign(scalar<MPF>& r, double d )        { mpf_set_d(&r.rep(),d); }

} //namespace mmx
//======================================================================
#endif // //SCL_MPF_H