big_float.hpp

Go to the documentation of this file.

/*****************************************************************************
    
    big_float.hpp -- Big Float Numbers implementation.

    This file is a part of the Arageli library.

    Copyright (C) Alexander Pshenichnikov, 2005--2006
    Copyright (C) Nikolay Santalov, 2005--2006
    
    University of Nizhni Novgorod, Russia

*****************************************************************************/

#include "config.hpp"

#include <iostream>
#include "std_import.hpp"
#include "big_int.hpp"

#ifndef _ARAGELI_big_float_h_
#define _ARAGELI_big_float_h_

#undef NAN

#pragma warning ( disable : 4018 )

namespace Arageli
{
 

// WARNING! Names are too simple and general.
// TODO: Rename or incapsulate them!
// WARNING! How does it combine with ISO C++ 18.2.1.3?

const int EXACT = 1; 
const int ROUND = 2; 
const int TO_NEAREST = 3; 
const int TO_ZERO = 4; 
const int TO_P_INF = 5; 
const int TO_M_INF = 6; 
const int TO_INF = 7;   



const int NAN = 1;
const int PINF = 2;
const int M_INF= 3;
const int P_ZERO = 4;
const int M_ZERO = 5;


const int PREC_MIN = 2;
const unsigned long PREC_MAX = _Internal::max_digit;
const unsigned long D_PREC_MAX = ( long ) (_Internal::max_digit * log ( 2.0l ) / log ( 10.0l )); 
 
class big_float
{

 public:

  big_float();                    
  big_float(const char *str);           
  big_float(const big_float & b); 
  big_float( const big_int &s, const big_int &e);
  big_float(double b );        
  big_float(int i);               
  ~big_float();                   

  big_float & operator = (const big_float & b);     
  big_float & operator = ( const double d );          
  big_float & operator = ( const char *str );         
  big_float & operator = ( const int i );                

  big_int get_exponent() const;

  big_int get_significant() const;

  friend std::ostream & operator << (std::ostream & s, const big_float & x);
  friend std::istream & operator >> (std::istream & s, big_float & x);
  void out ( std::ostream & os, char c = 'd' ) const ;
  void in ( std::istream &ins, char c = 'd' );

  static void set_global_precision(long p); 
  static void set_round_mode (int m = TO_NEAREST);


  friend int cmp(const big_float & a, const big_float & b);
  friend int operator ==(const big_float & a, const big_float & b);
  friend int operator !=(const big_float & a, const big_float & b);
  friend int operator > (const big_float & a, const big_float & b);
  friend int operator >=(const big_float & a, const big_float & b);
  friend int operator < (const big_float & a, const big_float & b);
  friend int operator <=(const big_float & a, const big_float & b);

  friend big_float operator + (const big_float & a);       
  friend big_float operator - (const big_float & a);       

  friend big_float add(const big_float & b, const big_float & c, long prec, int mode);
  friend big_float add(const big_float & b, const big_float & c, long prec);
  friend big_float add(const big_float & b, const big_float & c);

  friend big_float sub(const big_float & b, const big_float & c, long prec, int mode);
  friend big_float sub(const big_float & b, const big_float & c, long prec);
  friend big_float sub(const big_float & b, const big_float & c);

  friend big_float mul(const big_float & b, const big_float & c, long prec, int mode);
  friend big_float mul(const big_float & b, const big_float & c, long prec);
  friend big_float mul(const big_float & b, const big_float & c);

  friend big_float div(const big_float & b, const big_float & c, long prec, int mode);
  friend big_float div(const big_float & b, const big_float & c, long prec);
  friend big_float div(const big_float & b, const big_float & c);
  friend big_float divnu(const big_float & b, const big_float & c, long prec, int mode);
  friend big_float div_i ( const big_int & c );
  friend big_float fsqrt(const big_float & b,/* const big_float & c,*/ long prec, int mode);
  friend big_float fsqrt(const big_float & b,/* const big_float & c,*/ long prec);
  friend big_float fsqrt(const big_float & b/*, const big_float & c*/);
  friend big_float nfsqrt(const big_float & b,/* const big_float & c,*/ long prec, int mode);

  friend big_float operator + (const big_float & b, const big_float & c);
  friend big_float operator - (const big_float & b, const big_float & c);
  friend big_float operator * (const big_float & b, const big_float & c);
  friend big_float operator / (const big_float & b, const big_float & c);
  friend big_float & operator += (big_float & b, const big_float & c);
  friend big_float & operator -= (big_float & b, const big_float & c);
  friend big_float & operator *= (big_float & b, const big_float & c);
  friend big_float & operator /= (big_float & b, const big_float & c);

  friend big_float ceil  (const big_float & a);
  friend big_float floor (const big_float & a);
  friend big_float frac  (const big_float & a);
  friend big_int iceil (const big_float & a);
  friend big_int ifloor(const big_float & a);
    
  friend big_float frandom  (long bits);
  friend big_float frandom  ( );
  friend big_float frandom1 (long bits, const big_int & exp = 0 );

  int is_NaN();     
  int is_pInf();    
  int is_mInf();    
  int is_Inf();     
  int is_pZero();   
  int is_mZero();   
  int is_Zero();    
  int is_Special(); 
    
 private:
  void normalize_1 ( long prec = big_float::prec, long mode = big_float::mode );
  
  // the following type is used inside the bigfloat unit and implements
  // the storage for a Big Float Number

  big_int e; 
  big_int s; //< significant

  int special;  
  
  static long prec; 
  static long mode; 
};


inline big_float abs (const big_float& x)
{ return is_negative(x) ? -x : x; }


template <typename Outiter>
inline void generate_range_helper (big_float& t1, const big_float& t2, Outiter outiter)
{ generate_range_helper_wo_inc(t1, t2, outiter); }


inline big_float & operator+= (big_float & b, const big_float & c)
{ return b = b + c; }

inline big_float & operator-= (big_float & b, const big_float & c)
{ return b = b - c; }

inline big_float & operator*= (big_float & b, const big_float & c)
{ return b = b * c; }

inline big_float & operator/= (big_float & b, const big_float & c)
{ return b = b / c; }



}

#endif

---