mpf.h

Go to the documentation of this file.

/* Part of the C++ Multi-Precision arithmetic library

   Written by Brian Sipos <bjs5075@rit.edu> or <brian@sipos.yi.org>
   Copyright 2001,2002,2003 Brian Sipos

   The MP++ library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   The MP++ library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with the MP++ library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef MPF_H
#define MPF_H

#include "mpi.h"

namespace mp {

class mpf_ : public mpi_ {
 public:
  typedef mp::float_type float_type; 

  static const byte capabilities();

  static void resetMinPrecision();
  static void setMinPrecision(size_type p);
  static size_type getMinPrecision();

  mpf_() {}
  mpf_(int_type n, size_type p = 0) {
    init(n, p);
  }
  mpf_(float_type n, size_type p = 0) {
    init(n, p);
  }
  mpf_(const mpi_ &n, size_type p = 0) {
    init(n, p);
  }
  mpf_(const mpf_ &n, size_type p = 0) {
    init(n, p);
  }

  int_type toInt() const;
  float_type toFloat() const;

  // Initialization functions (called from above)
  void init(int_type n, size_type p = 0);
  void init(float_type n, size_type p = 0);
  void init(const mpi_ &n, size_type p = 0);
  void init(const mpf_ &n, size_type p = 0);

  void setPrecision(size_type prec);

  void clear(); 

  void swap(mpf_ &n);

  mpi_ ipart() const; // The non-rounded integer part, as MPI
  mpi_ fpart() const; // The fractional part, copied as is, as MPI

  mpf_ getIntPart() const; // Integer part, as MPF
  mpf_ getFractPart() const; // Fraction part, as MPF

  size_type accuracy() const;
  size_type accuracy(const mpf_ &n) const;

  int compare(const mpf_ &n) const;

  size_type getPrecision() const;
  size_type getExponant() const;

  bool hasIntPart() const;
  bool hasFractPart() const;

  void normalize(mpf_ &n);

  void add(const mpf_ &n, size_type p = 0);
  void sub(const mpf_ &n, size_type p = 0);
  void mul(const mpf_ &n, size_type p = 0);
  void div(const mpf_ &n, size_type p = 0);
  void mod(const mpf_ &n, size_type p = 0);

  void mul_pow2(size_type n);
  void div_pow2(size_type n);

  void sqr();

  mpf_ pow(const mpf_ &n, size_type p = 0) const;

  mpf_ sqrt(size_type p = 0) const;

  mpf_ root(limb_type n, size_type p = 0) const;

  mpf_ exp(size_type p = 0) const;

  mpf_ log(size_type p = 0) const;

  mpf_ agm(const mpf_ &n, size_type p) const;

  void pi(size_type p);

  void setString(const std::string &s, radix_type b = 0);

  std::string getString(radix_type b = string_base) const;

  void print() const;

  void checkExp();

 protected:
  static       size_type min_precision; 
  static const size_type min_prec_default; 

  size_type exp_; 

 private:
  void add_sub(const mpf_ &n, size_type p, bool subtract);
};

class mpf : public mpf_ {
 public:
  mpf(const mpf_ &n) : mpf_(n) {} // Casting up

  mpf() {}
  mpf(int_type n, size_type p = 0) : mpf_(n, p) {}
  mpf(float_type n, size_type p = 0) : mpf_(n, p) {}
  mpf(const mpi &n, size_type p = 0) : mpf_(n, p) {}
  mpf(const mpf &n, size_type p = 0) : mpf_(n, p) {}
  mpf(const std::string &s, char b = 0) {
    setString(s, b);
  }

  operator int_type() const {
    return toInt();
  }
  operator float_type() const {
    return toFloat();
  }
  operator std::string() const {
    return getString();
  }
  operator mpi() const {
    return ipart();
  }

  mpf & operator ++ ();
  const mpf operator ++ (int);

  mpf & operator -- ();
  const mpf operator -- (int);

  const mpf & operator = (int_type n);
  const mpf & operator = (float_type n);
  const mpf & operator = (const mpi &n);
  const mpf & operator = (const mpf &n);
  const mpf & operator = (const std::string &n);

  // Addition overloads
  const mpf & operator += (int_type n);
  const mpf & operator += (float_type n);
  const mpf & operator += (const mpi &n);
  const mpf & operator += (const mpf &n);

  // Subtraction overloads
  const mpf & operator -= (int_type n);
  const mpf & operator -= (float_type n);
  const mpf & operator -= (const mpi &n);
  const mpf & operator -= (const mpf &n);

  // Multiplication overloads
  const mpf & operator *= (int_type n);
  const mpf & operator *= (float_type n);
  const mpf & operator *= (const mpi &n);
  const mpf & operator *= (const mpf &n);

  // Division overloads
  const mpf & operator /= (int_type n);
  const mpf & operator /= (float_type n);
  const mpf & operator /= (const mpi &n);
  const mpf & operator /= (const mpf &n);

  const mpf & operator %= (const mpf &n);

};

std::istream & operator >> (std::istream &is, mpf &n);
std::ostream & operator << (std::ostream &os, const mpf &n);

//mpf::size_type accuracy(const mpf &x);

// Comparison function and overloads
bool operator == (const mpf &x, int_type y);
bool operator != (const mpf &x, int_type y);
bool operator <  (const mpf &x, int_type y);
bool operator <= (const mpf &x, int_type y);
bool operator >  (const mpf &x, int_type y);
bool operator >= (const mpf &x, int_type y);

bool operator == (const mpf &x, float_type y);
bool operator != (const mpf &x, float_type y);
bool operator <  (const mpf &x, float_type y);
bool operator <= (const mpf &x, float_type y);
bool operator >  (const mpf &x, float_type y);
bool operator >= (const mpf &x, float_type y);

bool operator == (const mpf &x, const mpi &y);
bool operator != (const mpf &x, const mpi &y);
bool operator <  (const mpf &x, const mpi &y);
bool operator <= (const mpf &x, const mpi &y);
bool operator >  (const mpf &x, const mpi &y);
bool operator >= (const mpf &x, const mpi &y);

bool operator == (const mpf &x, const mpf &y);
bool operator != (const mpf &x, const mpf &y);
bool operator <  (const mpf &x, const mpf &y);
bool operator <= (const mpf &x, const mpf &y);
bool operator >  (const mpf &x, const mpf &y);
bool operator >= (const mpf &x, const mpf &y);

mpf operator + (const mpf &x);
mpf operator - (const mpf &x);

// Addition overloads
mpf operator + (const mpf &x, int_type y);
mpf operator + (int_type x, const mpf &y);
mpf operator + (const mpf &x, float_type y);
mpf operator + (float_type x, const mpi &y);
mpf operator + (const mpf &x, const mpi &y);
mpf operator + (const mpi &x, const mpf &y);
mpf operator + (const mpf &x, const mpf &y);

// Subtraction overloads
mpf operator - (const mpf &x, int_type y);
mpf operator - (int_type x, const mpf &y);
mpf operator - (const mpf &x, float_type y);
mpf operator - (float_type x, const mpi &y);
mpf operator - (const mpf &x, const mpi &y);
mpf operator - (const mpi &x, const mpf &y);
mpf operator - (const mpf &x, const mpf &y);

// Multiplication overloads
mpf operator * (const mpf &x, int_type y);
mpf operator * (int_type x, const mpf &y);
mpf operator * (const mpf &x, float_type y);
mpf operator * (float_type x, const mpi &y);
mpf operator * (const mpf &x, const mpi &y);
mpf operator * (const mpi &x, const mpf &y);
mpf operator * (const mpf &x, const mpf &y);

// Division overloads
mpf operator / (const mpf &x, int_type y);
mpf operator / (int_type x, const mpf &y);
mpf operator / (const mpf &x, float_type y);
mpf operator / (float_type x, const mpf &y);
mpf operator / (const mpf &x, const mpi &y);
mpf operator / (const mpi &x, const mpf &y);
mpf operator / (const mpf &x, const mpf &y);

mpf operator % (const mpf &x, const mpf &y);

mpf abs(const mpf &n);
mpf round(const mpf &x, size_type a);

mpf pow(const mpf &x, const mpf &n, size_type p = 0);
mpf sqr(const mpf &n);

mpf root(const mpf &x, limb_type n, size_type p = 0);
mpf sqrt(const mpf &n, size_type p = 0);

mpf exp(const mpf &n, size_type p = 0);

mpf agm(const mpf &x, const mpf &y, size_type p);

mpf log(const mpf &n, size_type p = 0);

mpf pi(size_type a);
 
void sin_cos(mpf &sin, mpf &cos, const mpf &theta, size_type p);

mpf sin(const mpf &theta, size_type p = 0);
mpf cos(const mpf &theta, size_type p = 0);
mpf tan(const mpf &theta, size_type p = 0);

mpf asin(const mpf &x, size_type p = 0);
mpf acos(const mpf &x, size_type p = 0);
mpf atan(const mpf &x, size_type p = 0);

} // End namespace mp
#endif

---