AndroMeta/include/AndroMeta/MReal.h

Go to the documentation of this file.

/*
 * Copyright 2009-2012 AndroMeta LLC. All rights reserved.
 *
 * AndroMeta LLC retains all intellectual property and proprietary 
 * rights to this software and related documentation and any modifications 
 * thereto.  Any use, reproduction, disclosure, or distribution of this 
 * software and related documentation without an express license agreement 
 * from AndroMeta LLC is strictly prohibited.
 * 
 */

#ifndef ANDROMETA_M_REAL_H
#define ANDROMETA_M_REAL_H

#include <iostream>
#include <ostream>

#include <AndroMeta/MStr.h>
#include <AndroMeta/MRational.h>

namespace Meta{
  
  class MReal{
  public:
    
    MReal();
    
    explicit MReal(const char* s);
    
    MReal(double x);
    
    MReal(int64_t x);
    
    MReal(int x);
    
    MReal(const MReal& r);
    
    MReal(const mrat& r);
    
    ~MReal();
    
    MReal& operator=(const MReal& r);
    
    MReal& operator+=(const MReal& r);
    
    template<typename T>
    MReal operator+(const T& t) const{
      MReal ret(*this);
      return ret += MReal(t);
    }
    
    MReal operator+(const MReal& x) const{
      MReal ret(*this);
      return ret += x;
    }
    
    MReal operator++(int){
      MReal ret(*this);
      *this += 1;
      return ret;
    }
    
    MReal& operator++(){
      return *this += 1;
    }
    
    MReal& operator-=(const MReal& r);
    
    template<typename T>
    MReal operator-(const T& t) const{
      MReal ret(*this);
      return ret -= MReal(t);
    }
    
    MReal operator-(const MReal& x) const{
      MReal ret(*this);
      return ret -= x;
    }
    
    MReal operator--(int){
      MReal ret(*this);
      *this -= 1;
      return ret;
    }
    
    MReal& operator--(){
      return *this -= 1;
    }
    
    MReal operator-() const;
    
    MReal& operator*=(const MReal& r);
    
    template<typename T>
    MReal operator*(const T& t) const{
      MReal ret(*this);
      return ret *= MReal(t);
    }
    
    MReal operator*(const MReal& x) const{
      MReal ret(*this);
      return ret *= x;
    }
    
    MReal& operator/=(const MReal& r);
    
    template<typename T>
    MReal operator/(const T& t) const{
      MReal ret(*this);
      return ret /= MReal(t);
    }
    
    MReal operator/(const MReal& x) const{
      MReal ret(*this);
      return ret /= x;
    }
    
    MReal& operator%=(const MReal& x);
    
    template<typename T>
    MReal operator%(const T& t) const{
      MReal ret(*this);
      return ret %= MReal(t);
    }
    
    MReal operator%(const MReal& x) const{
      MReal ret(*this);
      return ret %= x;
    }
    
    bool operator<(const MReal& x) const;
    
    template<typename T>
    bool operator<(const T& t) const{
      return *this < MReal(t);
    }
    
    bool operator>(const MReal& x) const;
    
    template<typename T>
    bool operator>(const T& t) const{
      return *this > MReal(t);
    }
    
    bool operator<=(const MReal& x) const;
    
    template<typename T>
    bool operator<=(const T& t) const{
      return *this <= MReal(t);
    }
    
    bool operator>=(const MReal& x) const;
    
    template<typename T>
    bool operator>=(const T& t) const{
      return *this >= MReal(t);
    }
    
    bool operator==(const MReal& x) const;
    
    template<typename T>
    bool operator==(const T& t) const{
      return *this == MReal(t);
    }
    
    bool operator!=(const MReal& x) const;
    
    template<typename T>
    bool operator!=(const T& t) const{
      return *this != MReal(t);
    }
    
    void setPrecision(size_t bits);
    
    static void setDefaultPrecision(size_t bits);
    
    static size_t defaultPrecision();
    
    double toDouble() const;
    
    int64_t toLong() const;
    
    mrat toRat() const;
    
    static MReal fromStr(const MStr& str);
    
    MStr toStr(bool exp=true, int precision=-1) const;
    
    static MReal cos(const MReal& x);
    
    static MReal sin(const MReal& x);
    
    static MReal tan(const MReal& x);
    
    static MReal acos(const MReal& x);
    
    static MReal asin(const MReal& x);
    
    static MReal atan(const MReal& x);
    
    static MReal atan2(const MReal& y, const MReal& x);
    
    static MReal cosh(const MReal& x);
    
    static MReal sinh(const MReal& x);
    
    static MReal tanh(const MReal& x);
    
    static MReal exp(const MReal& x);
    
    static MReal log(const MReal& x);
    
    static MReal log10(const MReal& x);
    
    static MReal pow(const MReal& base, const MReal& exponent);
    
    static MReal sqrt(const MReal& x);
    
    static MReal ceil(const MReal& x);
    
    static MReal floor(const MReal& x);
    
    static MReal abs(const MReal& x);
    
    static MReal pi();
    
    static MReal euler();
    
    static MReal catalan();

  private:
    class MReal_* x_;
  };
  
  typedef MReal mreal;
  
  template<typename T>
  inline bool operator<(const T& t, const MReal& x){
    return MReal(t) < x;
  }
  
  template<typename T>
  inline bool operator>(const T& t, const MReal& x){
    return MReal(t) > x;
  }
  
  template<typename T>
  inline bool operator<=(const T& t, const MReal& x){
    return MReal(t) <= x;
  }
  
  template<typename T>
  inline bool operator>=(const T& t, const MReal& x){
    return MReal(t) >= x;
  }
  
  template<typename T>
  inline bool operator==(const T& t, const MReal& x){
    return MReal(t) == x;
  }
  
  template<typename T>
  inline bool operator!=(const T& t, const MReal& x){
    return MReal(t) != x;
  }
  
  template<typename T>
  inline MReal operator+(const T& t, const MReal& x){
    return MReal(t) + x;
  }
  
  template<typename T>
  inline MReal operator-(const T& t, const MReal& x){
    return MReal(t) - x;
  }
  
  template<typename T>
  inline MReal operator*(const T& t, const MReal& x){
    return MReal(t) * x;
  }
  
  template<typename T>
  inline MReal operator/(const T& t, const MReal& x){
    return MReal(t) / x;
  }
  
  template<typename T>
  inline MReal operator%(const T& t, const MReal& x){
    return MReal(t) % x;
  }
  
  inline std::ostream& operator<<(std::ostream& ostr, const MReal& r){
    return ostr << r.toStr();
  }
  
} // end namespace Meta

#endif // ANDROMETA_M_REAL_H