/*
Copyright (C) 2001 - 2013 Evan Teran
                          evan.teran@gmail.com

This program 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.

This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <config-kcalc.h>
#include "knumber_integer.h"
#include "knumber_float.h"
#include "knumber_fraction.h"
#include "knumber_error.h"
#include <QScopedArrayPointer>
#include <QDebug>

namespace detail {

bool knumber_fraction::default_fractional_input              = false;
bool knumber_fraction::default_fractional_output             = true;
bool knumber_fraction::split_off_integer_for_fraction_output = false;

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
void knumber_fraction::set_default_fractional_input(bool value) {
	default_fractional_input = value;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
void knumber_fraction::set_default_fractional_output(bool value) {
	default_fractional_output = value;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
void knumber_fraction::set_split_off_integer_for_fraction_output(bool value) {
	split_off_integer_for_fraction_output = value;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_fraction::knumber_fraction(const QString &s) {
	mpq_init(mpq_);
	mpq_set_str(mpq_, s.toAscii(), 10);
	mpq_canonicalize(mpq_);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_fraction::knumber_fraction(qint64 num, quint64 den) {
	mpq_init(mpq_);
	mpq_set_si(mpq_, num, den);
	mpq_canonicalize(mpq_);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_fraction::knumber_fraction(quint64 num, quint64 den) {
	mpq_init(mpq_);
	mpq_set_ui(mpq_, num, den);
	mpq_canonicalize(mpq_);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_fraction::knumber_fraction(mpq_t mpq) {
	mpq_init(mpq_);
	mpq_set(mpq_, mpq);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_fraction::knumber_fraction(const knumber_fraction *value) {
	mpq_init(mpq_);
	mpq_set(mpq_, value->mpq_);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_fraction::knumber_fraction(const knumber_integer *value) {
	mpq_init(mpq_);
	mpq_set_z(mpq_, value->mpz_);
}

#if 0
//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_fraction::knumber_fraction(const knumber_float *value) {
	mpq_init(mpq_);
	mpq_set_f(mpq_, value->mpf_);
}
#endif

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::clone() {
	return new knumber_fraction(this);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_fraction::~knumber_fraction() {
	mpq_clear(mpq_);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
bool knumber_fraction::is_integer() const {
	return (mpz_cmp_ui(mpq_denref(mpq_), 1) == 0);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::add(knumber_base *rhs) {

	if(knumber_integer *const p = dynamic_cast<knumber_integer *>(rhs)) {
		knumber_fraction q(p);
		mpq_add(mpq_, mpq_, q.mpq_);
		return this;
	} else if(knumber_float *const p = dynamic_cast<knumber_float *>(rhs)) {
		knumber_float *f = new knumber_float(this);
		delete this;
		return f->add(p);
	} else if(knumber_fraction *const p = dynamic_cast<knumber_fraction *>(rhs)) {
		mpq_add(mpq_, mpq_, p->mpq_);
		return this;
	} else if(knumber_error *const p = dynamic_cast<knumber_error *>(rhs)) {
		knumber_error *e = new knumber_error(p);
		delete this;
		return e;
	}

	Q_ASSERT(0);
	return 0;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::sub(knumber_base *rhs) {

	if(knumber_integer *const p = dynamic_cast<knumber_integer *>(rhs)) {
		knumber_fraction q(p);
		mpq_sub(mpq_, mpq_, q.mpq_);
		return this;
	} else if(knumber_float *const p = dynamic_cast<knumber_float *>(rhs)) {
		knumber_float *f = new knumber_float(this);
		delete this;
		return f->sub(p);
	} else if(knumber_fraction *const p = dynamic_cast<knumber_fraction *>(rhs)) {
		mpq_sub(mpq_, mpq_, p->mpq_);
		return this;
	} else if(knumber_error *const p = dynamic_cast<knumber_error *>(rhs)) {
		knumber_error *e = new knumber_error(p);
		delete this;
		return e->neg();
	}

	Q_ASSERT(0);
	return 0;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::mul(knumber_base *rhs) {

	if(knumber_integer *const p = dynamic_cast<knumber_integer *>(rhs)) {
		knumber_fraction q(p);
		mpq_mul(mpq_, mpq_, q.mpq_);
		return this;
	} else if(knumber_float *const p = dynamic_cast<knumber_float *>(rhs)) {
		knumber_float *q = new knumber_float(this);
		delete this;
		return q->mul(p);
	} else if(knumber_fraction *const p = dynamic_cast<knumber_fraction *>(rhs)) {
		mpq_mul(mpq_, mpq_, p->mpq_);
		return this;
	} else if(knumber_error *const p = dynamic_cast<knumber_error *>(rhs)) {
		if(is_zero()) {
			delete this;
			knumber_error *e = new knumber_error(knumber_error::ERROR_UNDEFINED);
			return e;
		}

		if(sign() < 0) {
			delete this;
			knumber_error *e = new knumber_error(p);
			return e->neg();
		} else {
			delete this;
			knumber_error *e = new knumber_error(p);
			return e;
		}
	}

	Q_ASSERT(0);
	return 0;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::div(knumber_base *rhs) {

	if(rhs->is_zero()) {
		if(sign() < 0) {
			delete this;
			return new knumber_error(knumber_error::ERROR_NEG_INFINITY);
		} else {
			delete this;
			return new knumber_error(knumber_error::ERROR_POS_INFINITY);
		}
	}

	if(knumber_integer *const p = dynamic_cast<knumber_integer *>(rhs)) {
		knumber_fraction f(p);
		return div(&f);
	} else if(knumber_float *const p = dynamic_cast<knumber_float *>(rhs)) {
		knumber_float *f = new knumber_float(this);
		delete this;
		return f->div(p);
	} else if(knumber_fraction *const p = dynamic_cast<knumber_fraction *>(rhs)) {
		mpq_div(mpq_, mpq_, p->mpq_);
		return this;
	} else if(knumber_error *const p = dynamic_cast<knumber_error *>(rhs)) {

		if(p->sign() > 0) {
			delete this;
			return new knumber_integer(0);
		} else if(p->sign() < 0) {
			delete this;
			return new knumber_integer(0);
		}

		knumber_error *e = new knumber_error(p);
		delete this;
		return e;
	}

	Q_ASSERT(0);
	return 0;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::mod(knumber_base *rhs) {

	if(rhs->is_zero()) {
		delete this;
		return new knumber_error(knumber_error::ERROR_UNDEFINED);
	}

	// NOTE: we don't support modulus operations with non-integer operands
	mpq_set_d(mpq_, 0);
	return this;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::bitwise_and(knumber_base *rhs) {

	Q_UNUSED(rhs);
	delete this;
	// NOTE: we don't support bitwise operations with non-integer operands
	return new knumber_integer(0);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::bitwise_xor(knumber_base *rhs) {

	Q_UNUSED(rhs);
	delete this;
	// NOTE: we don't support bitwise operations with non-integer operands
	return new knumber_integer(0);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::bitwise_or(knumber_base *rhs) {

	Q_UNUSED(rhs);
	delete this;
	// NOTE: we don't support bitwise operations with non-integer operands
	return new knumber_integer(0);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::bitwise_shift(knumber_base *rhs) {

	Q_UNUSED(rhs);
	delete this;
	// NOTE: we don't support bitwise operations with non-integer operands
	return new knumber_error(knumber_error::ERROR_UNDEFINED);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::neg() {
	mpq_neg(mpq_, mpq_);
	return this;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::abs() {
	mpq_abs(mpq_, mpq_);
	return this;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::cmp() {

	delete this;
	return new knumber_error(knumber_error::ERROR_UNDEFINED);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::sqrt() {

	if(sign() < 0) {
		delete this;
		return new knumber_error(knumber_error::ERROR_UNDEFINED);
	}

	if(mpz_perfect_square_p(mpq_numref(mpq_)) && mpz_perfect_square_p(mpq_denref(mpq_))) {
		mpz_t num;
		mpz_t den;
		mpz_init(num);
		mpz_init(den);
		mpq_get_num(num, mpq_);
		mpq_get_den(den, mpq_);
		mpz_sqrt(num, num);
		mpz_sqrt(den, den);
		mpq_set_num(mpq_, num);
		mpq_set_den(mpq_, den);
		mpq_canonicalize(mpq_);
		mpz_clear(num);
		mpz_clear(den);
		return this;
	} else {
		knumber_float *f = new knumber_float(this);
		delete this;
		return f->sqrt();
	}
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::cbrt() {

	// TODO: figure out how to properly use mpq_numref/mpq_denref here
	mpz_t num;
	mpz_t den;

	mpz_init(num);
	mpz_init(den);

	mpq_get_num(num, mpq_);
	mpq_get_den(den, mpq_);

	if(mpz_root(num, num, 3) && mpz_root(den, den, 3)) {
		mpq_set_num(mpq_, num);
		mpq_set_den(mpq_, den);
		mpq_canonicalize(mpq_);
		mpz_clear(num);
		mpz_clear(den);
		return this;
	} else {
		mpz_clear(num);
		mpz_clear(den);
		knumber_float *f = new knumber_float(this);
		delete this;
		return f->cbrt();
	}
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::factorial() {

	if(sign() < 0) {
		delete this;
		return new knumber_error(knumber_error::ERROR_UNDEFINED);
	}

	knumber_integer *i = new knumber_integer(this);
	delete this;
	return i->factorial();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::pow(knumber_base *rhs) {

	// TODO: figure out how to properly use mpq_numref/mpq_denref here
	if(knumber_integer *const p = dynamic_cast<knumber_integer *>(rhs)) {

		mpz_t num;
		mpz_t den;

		mpz_init(num);
		mpz_init(den);

		mpq_get_num(num, mpq_);
		mpq_get_den(den, mpq_);

		mpz_pow_ui(num, num, mpz_get_ui(p->mpz_));
		mpz_pow_ui(den, den, mpz_get_ui(p->mpz_));
		mpq_set_num(mpq_, num);
		mpq_set_den(mpq_, den);
		mpq_canonicalize(mpq_);
		mpz_clear(num);
		mpz_clear(den);

		if(p->sign() < 0) {
			return reciprocal();
		} else {
			return this;
		}
	} else if(knumber_float *const p = dynamic_cast<knumber_float *>(rhs)) {
		Q_UNUSED(p);
		knumber_float *f = new knumber_float(this);
		delete this;
		return f->pow(rhs);
	} else if(knumber_fraction *const p = dynamic_cast<knumber_fraction *>(rhs)) {

		// ok, so if any part of the number is > 1,000,000, then we risk
		// the pow function overflowing... so we'll just convert to float to be safe
		// TODO: at some point, we should figure out exactly what the threashold is
		//       and if there is a better way to determine if the pow function will
		//       overflow.
		if(mpz_cmpabs_ui(mpq_numref(mpq_), 1000000) > 0 || mpz_cmpabs_ui(mpq_denref(mpq_), 1000000) > 0 || mpz_cmpabs_ui(mpq_numref(p->mpq_), 1000000) > 0 || mpz_cmpabs_ui(mpq_denref(p->mpq_), 1000000) > 0) {
			knumber_float *f = new knumber_float(this);
			delete this;
			return f->pow(rhs);
		}

		mpz_t lhs_num;
		mpz_t lhs_den;
		mpz_t rhs_num;
		mpz_t rhs_den;

		mpz_init(lhs_num);
		mpz_init(lhs_den);
		mpz_init(rhs_num);
		mpz_init(rhs_den);

		mpq_get_num(lhs_num, mpq_);
		mpq_get_den(lhs_den, mpq_);
		mpq_get_num(rhs_num, p->mpq_);
		mpq_get_den(rhs_den, p->mpq_);

		mpz_pow_ui(lhs_num, lhs_num, mpz_get_ui(rhs_num));
		mpz_pow_ui(lhs_den, lhs_den, mpz_get_ui(rhs_num));

		if(mpz_sgn(lhs_num) < 0 && mpz_even_p(rhs_den)) {
			mpz_clear(lhs_num);
			mpz_clear(lhs_den);
			mpz_clear(rhs_num);
			mpz_clear(rhs_den);
			delete this;
			return new knumber_error(knumber_error::ERROR_UNDEFINED);
		}

		if(mpz_sgn(lhs_den) < 0 && mpz_even_p(rhs_den)) {
			mpz_clear(lhs_num);
			mpz_clear(lhs_den);
			mpz_clear(rhs_num);
			mpz_clear(rhs_den);
			delete this;
			return new knumber_error(knumber_error::ERROR_UNDEFINED);
		}

		const int n1 = mpz_root(lhs_num, lhs_num, mpz_get_ui(rhs_den));
		const int n2 = mpz_root(lhs_den, lhs_den, mpz_get_ui(rhs_den));

		if(n1 && n2) {

			mpq_set_num(mpq_, lhs_num);
			mpq_set_den(mpq_, lhs_den);
			mpq_canonicalize(mpq_);
			mpz_clear(lhs_num);
			mpz_clear(lhs_den);
			mpz_clear(rhs_num);
			mpz_clear(rhs_den);

			if(p->sign() < 0) {
				return reciprocal();
			} else {
				return this;
			}
		} else {
			mpz_clear(lhs_num);
			mpz_clear(lhs_den);
			mpz_clear(rhs_num);
			mpz_clear(rhs_den);
			knumber_float *f = new knumber_float(this);
			delete this;

			return f->pow(rhs);
		}

	} else if(knumber_error *const p = dynamic_cast<knumber_error *>(rhs)) {
		if(p->sign() > 0) {
			knumber_error *e = new knumber_error(knumber_error::ERROR_POS_INFINITY);
			delete this;
			return e;
		} else if(p->sign() < 0) {
			knumber_integer *n = new knumber_integer(0);
			delete this;
			return n;
		} else {
			knumber_error *e = new knumber_error(knumber_error::ERROR_UNDEFINED);
			delete this;
			return e;
		}
	}

	Q_ASSERT(0);
	return 0;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::sin() {

	knumber_float *f = new knumber_float(this);
	delete this;
	return f->sin();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::floor() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->floor();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::ceil() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->ceil();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::cos() {

	knumber_float *f = new knumber_float(this);
	delete this;
	return f->cos();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::tgamma() {

	knumber_float *f = new knumber_float(this);
	delete this;
	return f->tgamma();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::tan() {

	knumber_float *f = new knumber_float(this);
	delete this;
	return f->tan();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::asin() {

	knumber_float *f = new knumber_float(this);
	delete this;
	return f->asin();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::acos() {

	knumber_float *f = new knumber_float(this);
	delete this;
	return f->acos();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::atan() {

	knumber_float *f = new knumber_float(this);
	delete this;
	return f->atan();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::sinh() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->sinh();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::cosh() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->cosh();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::tanh() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->tanh();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::asinh() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->asinh();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::acosh() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->acosh();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::atanh() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->atanh();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
int knumber_fraction::compare(knumber_base *rhs) {

	if(knumber_integer *const p = dynamic_cast<knumber_integer *>(rhs)) {
		knumber_fraction f(p);
		return mpq_cmp(mpq_, f.mpq_);
	} else if(knumber_float *const p = dynamic_cast<knumber_float *>(rhs)) {
		knumber_float f(this);
		return f.compare(p);
	} else if(knumber_fraction *const p = dynamic_cast<knumber_fraction *>(rhs)) {
		return mpq_cmp(mpq_, p->mpq_);
	} else if(knumber_error *const p = dynamic_cast<knumber_error *>(rhs)) {
		// NOTE: any number compared to NaN/Inf/-Inf always compares less
		//       at the moment
		return -1;
	}

	Q_ASSERT(0);
	return 0;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
QString knumber_fraction::toString(int precision) const {


	if(knumber_fraction::default_fractional_output) {

		// TODO: figure out how to properly use mpq_numref/mpq_denref here

		knumber_integer integer_part(this);
		if(split_off_integer_for_fraction_output && !integer_part.is_zero()) {

			mpz_t num;
			mpz_init(num);
			mpq_get_num(num, mpq_);

			knumber_integer integer_part_1(this);

			mpz_mul(integer_part.mpz_, integer_part.mpz_, mpq_denref(mpq_));
			mpz_sub(num, num, integer_part.mpz_);

			if(mpz_sgn(num) < 0) {
				mpz_neg(num, num);
			}

    		const size_t size = gmp_snprintf(NULL, 0, "%Zd %Zd/%Zd", integer_part_1.mpz_, num, mpq_denref(mpq_)) + 1;
			QScopedArrayPointer<char> buf(new char[size]);
    		gmp_snprintf(&buf[0], size, "%Zd %Zd/%Zd", integer_part_1.mpz_, num, mpq_denref(mpq_));

			mpz_clear(num);

    		return QLatin1String(&buf[0]);
		} else {

			mpz_t num;
			mpz_init(num);
			mpq_get_num(num, mpq_);

    		const size_t size = gmp_snprintf(NULL, 0, "%Zd/%Zd", num, mpq_denref(mpq_)) + 1;
			QScopedArrayPointer<char> buf(new char[size]);
    		gmp_snprintf(&buf[0], size, "%Zd/%Zd", num, mpq_denref(mpq_));

			mpz_clear(num);

    		return QLatin1String(&buf[0]);
		}
	} else {
		return knumber_float(this).toString(precision);
	}
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
bool knumber_fraction::is_zero() const {
	return mpq_sgn(mpq_) == 0;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
int knumber_fraction::sign() const {
	return mpq_sgn(mpq_);
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::reciprocal() {

	mpq_inv(mpq_, mpq_);
	return this;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_integer *knumber_fraction::numerator() const {

	mpz_t num;
	mpz_init(num);
	mpq_get_num(num, mpq_);
	knumber_integer *n = new knumber_integer(num);
	mpz_clear(num);
	return n;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_integer *knumber_fraction::denominator() const {

	mpz_t den;
	mpz_init(den);
	mpq_get_den(den, mpq_);
	knumber_integer *n = new knumber_integer(den);
	mpz_clear(den);
	return n;
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::log2() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->log2();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::log10() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->log10();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::ln() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->ln();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::exp2() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->exp2();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::exp10() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->exp10();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::exp() {
	knumber_float *f = new knumber_float(this);
	delete this;
	return f->exp();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
quint64 knumber_fraction::toUint64() const {
	return knumber_integer(this).toUint64();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
qint64 knumber_fraction::toInt64() const {
	return knumber_integer(this).toInt64();
}

//------------------------------------------------------------------------------
// Name:
//------------------------------------------------------------------------------
knumber_base *knumber_fraction::bin(knumber_base *rhs) {
	Q_UNUSED(rhs);
	delete this;
	return new knumber_error(knumber_error::ERROR_UNDEFINED);

}

}