1) MultiPrecision class - operators reimplementation (f8552149) · Commits · TNL / tnl-dev

src/TNL/Experimental/Arithmetics/MultiPrecision.cpp

+91 −50

Original line number	Diff line number	Diff line
		/**************************************************
		* filename: MultiPrecision.cpp *
		* created: October 22, 2017 *
		* created: November 11, 2017 *
		* author: Daniel Simon *
		* mail: dansimon93@gmail.com *
		***************************************************/
		@@ -26,80 +26,121 @@ MultiPrecision::MultiPrecision(mpf_t number, mpf_t n){
		mpf_init_set(number, n);
		}

		/* ARITHMETIC FUNCTIONS */
		/* OPERATORS IMPLEMENTATION */

		MultiPrecision addition( MultiPrecision a, MultiPrecision b ){
		mpf_t result;
		mpf_init(result);
		mpf_add(result, a.number, b.number);
		return result;
		void MultiPrecision::operator=(const MultiPrecision& mp){
		mpf_set(number, mp.number);
		}

		MultiPrecision subtraction( MultiPrecision a, MultiPrecision b ){
		mpf_t result;
		mpf_init(result);
		mpf_sub(result, a.number, b.number);
		return result;
		MultiPrecision& MultiPrecision::operator-(){
		mpf_neg(this->number, this->number);
		return *this;
		}

		MultiPrecision multiplication( MultiPrecision a, MultiPrecision b ){
		mpf_t result;
		mpf_init(result);
		mpf_mul(result, a.number, b.number);
		return result;
		MultiPrecision& MultiPrecision::operator+=(const MultiPrecision& mp){
		mpf_add(this->number, this->number, mp.number);
		return *this;
		}

		MultiPrecision division( MultiPrecision a, MultiPrecision b ){
		mpf_t result;
		mpf_init(result);
		mpf_div(result, a.number, b.number);
		return result;
		MultiPrecision& MultiPrecision::operator-=(const MultiPrecision& mp){
		mpf_sub(this->number, this->number, mp.number);
		return *this;
		}

		MultiPrecision sqrt( MultiPrecision a ){
		mpf_t result;
		mpf_init(result);
		mpf_sqrt(result, a.number);
		return result;
		MultiPrecision& MultiPrecision::operator*=(const MultiPrecision& mp){
		mpf_mul(this->number, this->number, mp.number);
		return *this;
		}

		MultiPrecision power( MultiPrecision a, unsigned long int c ){
		mpf_t result;
		mpf_init(result);
		mpf_pow_ui(result, a.number, c);
		return result;
		MultiPrecision& MultiPrecision::operator/=(const MultiPrecision& mp){
		mpf_div(this->number, this->number, mp.number);
		return *this;
		}

		MultiPrecision negation( MultiPrecision a ){
		mpf_t result;
		mpf_init(result);
		mpf_neg(result, a.number);
		MultiPrecision MultiPrecision::operator+(const MultiPrecision& mp) const{
		MultiPrecision result = MultiPrecision(*this);
		result += mp;
		return result;
		}

		MultiPrecision abs( MultiPrecision a ){
		mpf_t result;
		mpf_init(result);
		mpf_abs(result, a.number);
		MultiPrecision MultiPrecision::operator-(const MultiPrecision& mp) const{
		MultiPrecision result = MultiPrecision(*this);
		result -= mp;
		return result;
		}

		MultiPrecision mul_2exp( MultiPrecision a, mp_bitcnt_t b){
		mpf_t result;
		mpf_init(result);
		mpf_mul_2exp(result, a.number, b);
		MultiPrecision MultiPrecision::operator*(const MultiPrecision& mp) const{
		MultiPrecision result = MultiPrecision(*this);
		result *= mp;
		return result;
		}

		MultiPrecision div_2exp( MultiPrecision a, mp_bitcnt_t b ){
		mpf_t result;
		mpf_init(result);
		mpf_div_2exp(result, a.number, b);
		MultiPrecision MultiPrecision::operator/(const MultiPrecision& mp) const{
		MultiPrecision result = MultiPrecision(*this);
		result /= mp;
		return result;
		}

		bool MultiPrecision::operator==(const MultiPrecision &mp) const{
		MultiPrecision m = MultiPrecision(*this);
		if (mpf_cmp(m.number, mp.number) == 0)
		return true;
		else
		return false;
		}

		bool MultiPrecision::operator!=(const MultiPrecision &mp) const{
		//MultiPrecision m = MultiPrecision(*this);
		//return !(m.number == mp.number);
		return !(*this == mp);
		}

		bool MultiPrecision::operator<(const MultiPrecision &mp) const{
		MultiPrecision m = MultiPrecision(*this);
		if (mpf_cmp(m.number, mp.number) < 0)
		return true;
		else
		return false;
		}

		bool MultiPrecision::operator>(const MultiPrecision &mp) const{
		MultiPrecision m = MultiPrecision(*this);
		if (mpf_cmp(m.number, mp.number) > 0)
		return true;
		else
		return false;
		}

		bool MultiPrecision::operator>=(const MultiPrecision &mp) const{
		MultiPrecision m = MultiPrecision(*this);
		if (mpf_cmp(m.number, mp.number) >= 0)
		return true;
		else
		return false;
		}

		bool MultiPrecision::operator<=(const MultiPrecision &mp) const{
		MultiPrecision m = MultiPrecision(*this);
		if (mpf_cmp(m.number, mp.number) <= 0)
		return true;
		else
		return false;
		}

		/* OPERATOR OVERLOADING */
		/* METHODS */
		void MultiPrecision::printMP(int precision){
		mpf_out_str(stdout, 10, precision, this->number);
		}

		MultiPrecision MultiPrecision::abs(MultiPrecision r, const MultiPrecision a){
		mpf_abs(r.number, a.number);
		return r;
		}

		MultiPrecision MultiPrecision::sqrt(MultiPrecision r, const MultiPrecision a){
		mpf_sqrt(r.number, a.number);
		return r;
		}


		/* DESTRUCTOR */

src/TNL/Experimental/Arithmetics/MultiPrecision.h

+36 −19

Original line number	Diff line number	Diff line
		/**************************************************
		* filename: MultiPrecision.h *
		* created: October 29, 2017 *
		* created: November 11, 2017 *
		* author: Daniel Simon *
		* mail: dansimon93@gmail.com *
		***************************************************/
		@@ -8,7 +8,6 @@
		/IMPLEMENTATION OF GMP LIBRARY - FLOATING POINT FUNCTIONS/
		/* Source: https://gmplib.org/ */


		#ifdef HAVE_GMP

		#include <gmp.h>
		@@ -17,7 +16,8 @@

		class MultiPrecision{
		public:
		mpf_t number; // number
		/* NUMBER */
		mpf_t number;

		/* INITIALIZATION OF NUMBER */
		MultiPrecision(mpf_t number); // inits number to 0
		@@ -25,19 +25,36 @@ public:
		MultiPrecision(mp_bitcnt_t precision); // sets the default precision
		MultiPrecision(mpf_t number, mpf_t n); // assigns n value to number

		/* ARITHMETIC FUNCTIONS */
		MultiPrecision addition( MultiPrecision a, MultiPrecision b ); // result = a + b
		MultiPrecision subtraction( MultiPrecision a, MultiPrecision b ); // result = a - b
		MultiPrecision multiplication( MultiPrecision a, MultiPrecision b ); // result = a * b
		MultiPrecision division( MultiPrecision a, MultiPrecision b ); // result = a / b
		MultiPrecision sqrt( MultiPrecision a ); // result = sqrt(a)
		MultiPrecision power( MultiPrecision a, unsigned long int c ); // result = b ** c
		MultiPrecision negation( MultiPrecision a ); // result = -b
		MultiPrecision abs( MultiPrecision a ); // result = \|a\|
		MultiPrecision mul_2exp( MultiPrecision a, mp_bitcnt_t b );
		MultiPrecision div_2exp( MultiPrecision a, mp_bitcnt_t b );

		/* OPERATORS OVERLOADING */

		~MultiPrecision(); // destructor
		/* OPERATORS */
		void operator=(const MultiPrecision& mp);
		MultiPrecision& operator-();
		MultiPrecision& operator+=(const MultiPrecision& mp);
		MultiPrecision& operator-=(const MultiPrecision& mp);
		MultiPrecision& operator*=(const MultiPrecision& mp);
		MultiPrecision& operator/=(const MultiPrecision& mp);
		MultiPrecision operator+(const MultiPrecision& mp) const;
		MultiPrecision operator-(const MultiPrecision& mp) const;
		MultiPrecision operator*(const MultiPrecision& mp) const;
		MultiPrecision operator/(const MultiPrecision& mp) const;
		bool operator==(const MultiPrecision &mp) const;
		bool operator!=(const MultiPrecision &mp) const;
		bool operator<(const MultiPrecision &mp) const;
		bool operator>(const MultiPrecision &mp) const;
		bool operator>=(const MultiPrecision &mp) const;
		bool operator<=(const MultiPrecision &mp) const;
		MultiPrecision& operator++(); // prefix
		MultiPrecision& operator--(); // prefix
		MultiPrecision operator++(int); // postfix
		MultiPrecision operator--(int); // postfix

		/* METHODS */
		void printMP(int precision);
		MultiPrecision abs(MultiPrecision r, const MultiPrecision a);
		MultiPrecision sqrt(MultiPrecision r, const MultiPrecision a);
		/// void printNumber(int digits, ostream& str = std::cout ); TODO

		/* DESTRUCTOR */
		~MultiPrecision();
		};

		/// ostream& operator << ( ostream& str, const MultiPrecision& p ); TODO