Real.h

/* Copyright 2019 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef COM_DAFER45_TBTK_ARBITRARY_PRECISION_REAL
#define COM_DAFER45_TBTK_ARBITRARY_PRECISION_REAL

#include "TBTK/Streams.h"

#include <string>

//cstddef is needed to work around compilation issue. (See
//https://gcc.gnu.org/gcc-4.9/porting_to.html)
#include <cstddef>
#include <gmpxx.h>

namespace TBTK{
namespace ArbitraryPrecision{

class Real{
public:
    Real();

    ~Real();

    Real(const Real &real);

    Real(unsigned int precision);

    Real(unsigned int precision, double value);

    Real(unsigned int precision, const std::string &value);

    Real& operator=(const Real &real);

    Real& operator=(double rhs);

    Real& operator=(const std::string &rhs);

    Real& operator+=(const Real &rhs);

    Real operator+(const Real &rhs) const;

    Real& operator-=(const Real &rhs);

    Real operator-(const Real &rhs) const;

    Real& operator*=(const Real &rhs);

    Real operator*(const Real &rhs) const;

    Real& operator/=(const Real &rhs);

    Real operator/(const Real &rhs) const;

    Real operator-() const;

    friend std::ostream& operator<<(std::ostream &os, const Real &real);

    const mpf_t& getValue() const;

    double getDouble() const;

    mp_bitcnt_t getPrecision() const;
private:
    mpf_t value;

    bool isInitialized;
};

inline Real::Real(){
    isInitialized = false;
}

inline Real::~Real(){
    if(isInitialized)
        mpf_clear(value);
}

inline Real::Real(const Real &real){
    mpf_init2(value, real.getPrecision());
    mpf_set(value, real.value);
    isInitialized = true;
}

inline Real::Real(unsigned int precision){
    mpf_init2(value, precision);
    isInitialized = true;
}

inline Real::Real(unsigned int precision, double value){
    mpf_init2(this->value, precision);
    operator=(value);
    isInitialized = true;
}

inline Real::Real(unsigned int precision, const std::string &value){
    mpf_init2(this->value, precision);
    operator=(value);
    isInitialized = true;
}

inline Real& Real::operator=(const Real &rhs){
    if(this != &rhs){
        if(isInitialized)
            mpf_clear(value);

        mpf_init2(value, rhs.getPrecision());
        mpf_set(value, rhs.value);
        isInitialized = true;
    }

    return *this;
}

inline Real& Real::operator=(double rhs){
    mpf_set_d(value, rhs);

    return *this;
}

inline Real& Real::operator=(const std::string &rhs){
    mpf_set_str(value, rhs.c_str(), 10);

    return *this;
}

inline Real& Real::operator+=(const Real &rhs){
    mpf_add(value, value, rhs.value);

    return *this;
}

inline Real Real::operator+(const Real &rhs) const{
    Real real = *this;

    return real += rhs;
}

inline Real& Real::operator-=(const Real &rhs){
    mpf_sub(value, value, rhs.value);

    return *this;
}

inline Real Real::operator-(const Real &rhs) const{
    Real real = *this;

    return real -= rhs;
}

inline Real& Real::operator*=(const Real &rhs){
    mpf_mul(value, value, rhs.value);

    return *this;
}

inline Real Real::operator*(const Real &rhs) const{
    Real real = *this;

    return real *= rhs;
}

inline Real& Real::operator/=(const Real &rhs){
    mpf_div(value, value, rhs.value);

    return *this;
}

inline Real Real::operator/(const Real &rhs) const{
    Real real = *this;

    return real /= rhs;
}

inline Real Real::operator-() const{
    Real real;
    mpf_init2(real.value, getPrecision());
    mpf_neg(real.value, value);
    real.isInitialized = true;

    return real;
}

inline std::ostream& operator<<(std::ostream &os, const Real &real){
    os << real.value;

    return os;
}

inline const mpf_t& Real::getValue() const{
    return value;
}

inline double Real::getDouble() const{
    return mpf_get_d(value);
}

inline mp_bitcnt_t Real::getPrecision() const{
    return mpf_get_prec(value);
}

}; //End of namespace ArbitraryPrecision
}; //End of namesapce TBTK

#endif