File indexing completed on 2024-05-12 17:21:04

 // SPDX-FileCopyrightText: 2001-2013 Evan Teran <evan.teran@gmail.com>
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "knumber.h"
 #include "knumber_base.h"
 #include "knumber_error.h"
 #include "knumber_float.h"
 #include "knumber_fraction.h"
 #include "knumber_integer.h"
 #include <QDebug>
 #include <QLocale>
 #include <QRegularExpression>
 #include <QStringList>
 #include <cmath>
 
 QString KNumber::GroupSeparator   = QStringLiteral(",");
 QString KNumber::DecimalSeparator = QLocale::system().decimalPoint();
 const KNumber KNumber::Zero(QStringLiteral("0"));
 const KNumber KNumber::One(QStringLiteral("1"));
 const KNumber KNumber::NegOne(QStringLiteral("-1"));
 const KNumber KNumber::PosInfinity(QStringLiteral("inf"));
 const KNumber KNumber::NegInfinity(QStringLiteral("-inf"));
 const KNumber KNumber::NaN(QStringLiteral("nan"));
 
 namespace {
 namespace impl {
 
 //------------------------------------------------------------------------------
 // Name: increment
 //------------------------------------------------------------------------------
 void increment(QString &str, int position) {
 
     for (int i = position; i >= 0; i--) {
         const char last_char = str[i].toLatin1();
         switch (last_char) {
         case '0':
             str[i] = QLatin1Char('1');
             break;
         case '1':
             str[i] = QLatin1Char('2');
             break;
         case '2':
             str[i] = QLatin1Char('3');
             break;
         case '3':
             str[i] = QLatin1Char('4');
             break;
         case '4':
             str[i] = QLatin1Char('5');
             break;
         case '5':
             str[i] = QLatin1Char('6');
             break;
         case '6':
             str[i] = QLatin1Char('7');
             break;
         case '7':
             str[i] = QLatin1Char('8');
             break;
         case '8':
             str[i] = QLatin1Char('9');
             break;
         case '9':
             str[i] = QLatin1Char('0');
             if (i == 0) {
                 str.prepend(QLatin1Char('1'));
             }
             continue;
         case '.':
             continue;
         }
         break;
     }
 }
 
 //------------------------------------------------------------------------------
 // Name: round
 //------------------------------------------------------------------------------
 void round(QString &str, int precision) {
 
     // Cut off if more digits in fractional part than 'precision'
 
     int decimalSymbolPos = str.indexOf(QLatin1Char('.'));
 
     if (decimalSymbolPos == -1) {
         if (precision == 0) {
             return;
         } else if (precision > 0) {   // add dot if missing (and needed)
             str.append(QLatin1Char('.'));
             decimalSymbolPos = str.length() - 1;
         }
     }
 
     // fill up with more than enough zeroes (in case fractional part too short)
     str.append(QString().fill(QLatin1Char('0'), precision));
 
     // Now decide whether to round up or down
     const char last_char = str[decimalSymbolPos + precision + 1].toLatin1();
     switch (last_char) {
     case '0':
     case '1':
     case '2':
     case '3':
     case '4':
         // nothing to do, rounding down
         break;
     case '5':
     case '6':
     case '7':
     case '8':
     case '9':
         // rounding up
         increment(str, decimalSymbolPos + precision);
         break;
     default:
         break;
     }
 
     decimalSymbolPos = str.indexOf(QLatin1Char('.'));
     str.truncate(decimalSymbolPos + precision + 1);
 
     // if precision == 0 delete also '.'
     if (precision == 0) {
         str = str.section(QLatin1Char('.'), 0, 0);
     }
 }
 }
 
 //------------------------------------------------------------------------------
 // Name: round
 //------------------------------------------------------------------------------
 QString round(const QString &s, int precision) {
 
     QString tmp = s;
     if (precision < 0 || !QRegularExpression(QLatin1String("^[+-]?\\d+(\\.\\d+)*(e[+-]?\\d+)?$")).match(tmp).hasMatch()) {
         return s;
     }
 
     // Skip the sign (for now)
     const bool neg = (tmp[0] == QLatin1Char('-'));
     if (neg || tmp[0] == QLatin1Char('+')) {
         tmp.remove(0, 1);
     }
 
     // Split off exponential part (including 'e'-symbol)
     QString mantString = tmp.section(QLatin1Char('e'), 0, 0, QString::SectionCaseInsensitiveSeps);
     QString expString  = tmp.section(QLatin1Char('e'), 1, 1, QString::SectionCaseInsensitiveSeps | QString::SectionIncludeLeadingSep);
 
     if (expString.length() == 1) {
         expString.clear();
     }
 
     impl::round(mantString, precision);
 
     if (neg) {
         mantString.prepend(QLatin1Char('-'));
     }
 
     return mantString + expString;
 }
 }
 
 //------------------------------------------------------------------------------
 // Name: setGroupSeparator
 //------------------------------------------------------------------------------
 void KNumber::setGroupSeparator(const QString &ch) {
     GroupSeparator = ch;
 }
 
 //------------------------------------------------------------------------------
 // Name: setDecimalSeparator
 //------------------------------------------------------------------------------
 void KNumber::setDecimalSeparator(const QString &ch) {
     DecimalSeparator = ch;
 }
 
 //------------------------------------------------------------------------------
 // Name: groupSeparator
 //------------------------------------------------------------------------------
 QString KNumber::groupSeparator() {
     return GroupSeparator;
 }
 
 //------------------------------------------------------------------------------
 // Name: decimalSeparator
 //------------------------------------------------------------------------------
 QString KNumber::decimalSeparator() {
     return DecimalSeparator;
 }
 
 //------------------------------------------------------------------------------
 // Name: setDefaultFloatPrecision
 //------------------------------------------------------------------------------
 void KNumber::setDefaultFloatPrecision(int precision) {
     // Need to transform decimal digits into binary digits
     const unsigned long int bin_prec = static_cast<unsigned long int>(::ceil(precision * M_LN10 / M_LN2) + 1);
     mpfr_set_default_prec(static_cast<mpfr_prec_t>(bin_prec));
 }
 
 //------------------------------------------------------------------------------
 // Name: setSplitoffIntegerForFractionOutput
 //------------------------------------------------------------------------------
 void KNumber::setSplitoffIntegerForFractionOutput(bool x) {
     detail::knumber_fraction::set_split_off_integer_for_fraction_output(x);
 }
 
 //------------------------------------------------------------------------------
 // Name: setDefaultFractionalInput
 //------------------------------------------------------------------------------
 void KNumber::setDefaultFractionalInput(bool x) {
     detail::knumber_fraction::set_default_fractional_input(x);
 }
 
 //------------------------------------------------------------------------------
 // Name: setDefaultFloatOutput
 //------------------------------------------------------------------------------
 void KNumber::setDefaultFloatOutput(bool x) {
     detail::knumber_fraction::set_default_fractional_output(!x);
 }
 
 //------------------------------------------------------------------------------
 // Name: Pi
 //------------------------------------------------------------------------------
 KNumber KNumber::Pi() {
 
     // TODO: after 4.10 release:
     //       create a new constructor which works just like the normal QString
     //       accepting constructor, but allows us to specify separator
     //       characters, this will allow things to be done slightly more
     // efficiently
     QString s(QStringLiteral("3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068"));
     s.replace(QLatin1Char('.'), DecimalSeparator);
     return KNumber(s);
 }
 
 //------------------------------------------------------------------------------
 // Name: Euler
 //------------------------------------------------------------------------------
 KNumber KNumber::Euler() {
 
     // TODO: after 4.10 release:
     //       create a new constructor which works just like the normal QString
     //       accepting constructor, but allows us to specify separator
     //       characters, this will allow things to be done slightly more
     // efficiently
     QString s(QStringLiteral("2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274"));
     s.replace(QLatin1Char('.'), DecimalSeparator);
     return KNumber(s);
 }
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber() : value_(new detail::knumber_integer(0)) {
 }
 KNumber KNumber::binaryFromString(const QString &s)
 {
     KNumber instance(0);
     delete instance.value_;
     instance.value_ = detail::knumber_integer::binaryFromString(s);
     return instance;
 }
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(const QString &s) : value_(nullptr) {
     const QRegularExpression special_regex(QLatin1String("^(inf|-inf|nan)$"));
     const QRegularExpression integer_regex(QLatin1String("^[+-]?\\d+$"));
     const QRegularExpression fraction_regex(QLatin1String("^[+-]?\\d+/\\d+$"));
     const QRegularExpression float_regex(QLatin1String("^([+-]?\\d*)(%1\\d*)?(e([+-]?\\d+))?$").arg(QRegularExpression::escape(DecimalSeparator)));
 
     if (special_regex.match(s).hasMatch()) {
         value_ = new detail::knumber_error(s);
     } else if (integer_regex.match(s).hasMatch()) {
         value_ = new detail::knumber_integer(s);
     } else if (fraction_regex.match(s).hasMatch()) {
         value_ = new detail::knumber_fraction(s);
         simplify();
     } else if (float_regex.match(s).hasMatch()) {
         if (detail::knumber_fraction::default_fractional_input) {
             const QStringList list = float_regex.match(s).capturedTexts();
             const QString ipart = list[1];
             const QString fpart = list[2];
             const int e_val = list.size() == 5 ? list[4].toInt() : 0;
 
             QString num = ipart + fpart.mid(1);
             QString den = QLatin1String("1") + QString(fpart.size() - 1, QLatin1Char('0'));
 
             if (e_val < 0) {
                 den = den + QString(::abs(e_val), QLatin1Char('0'));
             } else if (e_val > 0) {
                 num = num + QString(::abs(e_val), QLatin1Char('0'));
             }
 
             value_ = new detail::knumber_fraction(QStringLiteral("%1/%2").arg(num, den));
             simplify();
             return;
         }
 
         // we need to normalize the decimal separator to US style because that's
         // the only type that the GMP function accept
         QString new_s = s;
         new_s.replace(DecimalSeparator, QLatin1String("."));
 
         value_ = new detail::knumber_float(new_s);
         simplify();
     } else {
         value_ = new detail::knumber_error(detail::knumber_error::ERROR_UNDEFINED);
     }
 }
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(qint32 value) : value_(new detail::knumber_integer(value)) {
 }
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(qint64 value) : value_(new detail::knumber_integer(value)) {
 }
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(quint32 value) : value_(new detail::knumber_integer(value)) {
 }
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(quint64 value) : value_(new detail::knumber_integer(value)) {
 }
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(qint64 num, quint64 den) : value_(new detail::knumber_fraction(num, den)) {
 }
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(quint64 num, quint64 den) : value_(new detail::knumber_fraction(num, den)) {
 }
 
 #ifdef HAVE_LONG_DOUBLE
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(long double value) : value_(new detail::knumber_float(value)) {
     simplify();
 }
 #endif
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(double value) : value_(new detail::knumber_float(value)) {
     simplify();
 }
 
 //------------------------------------------------------------------------------
 // Name: KNumber
 //------------------------------------------------------------------------------
 KNumber::KNumber(const KNumber &other) : value_(nullptr) {
     if(&other != this) {
         value_ = other.value_->clone();
     }
 }
 
 //------------------------------------------------------------------------------
 // Name: ~KNumber
 //------------------------------------------------------------------------------
 KNumber::~KNumber() {
     delete value_;
 }
 
 //------------------------------------------------------------------------------
 // Name: type
 //------------------------------------------------------------------------------
 KNumber::Type KNumber::type() const {
 
     if(dynamic_cast<detail::knumber_integer *>(value_)) {
         return TYPE_INTEGER;
     } else if(dynamic_cast<detail::knumber_float *>(value_)) {
         return TYPE_FLOAT;
     } else if(dynamic_cast<detail::knumber_fraction *>(value_)) {
         return TYPE_FRACTION;
     } else if(dynamic_cast<detail::knumber_error *>(value_)) {
         return TYPE_ERROR;
     } else {
         Q_ASSERT(0);
         return TYPE_ERROR;
     }
 }
 
 //------------------------------------------------------------------------------
 // Name: operator=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator=(const KNumber &rhs) {
     KNumber(rhs).swap(*this);
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: swap
 //------------------------------------------------------------------------------
 void KNumber::swap(KNumber &other) {
     qSwap(value_, other.value_);
 }
 
 //------------------------------------------------------------------------------
 // Name: integerPart
 //------------------------------------------------------------------------------
 KNumber KNumber::integerPart() const {
 
     KNumber x(*this);
 
     if(detail::knumber_integer *const p = dynamic_cast<detail::knumber_integer *>(value_)) {
         // NO-OP
         Q_UNUSED(p);
     } else if(detail::knumber_float *const p = dynamic_cast<detail::knumber_float *>(value_)) {
         detail::knumber_base *v = new detail::knumber_integer(p);
         qSwap(v, x.value_);
         delete v;
     } else if(detail::knumber_fraction *const p = dynamic_cast<detail::knumber_fraction *>(value_)) {
         detail::knumber_base *v = new detail::knumber_integer(p);
         qSwap(v, x.value_);
         delete v;
     } else if(detail::knumber_error *const p = dynamic_cast<detail::knumber_error *>(value_)) {
         // NO-OP
         Q_UNUSED(p);
     } else {
         Q_ASSERT(0);
     }
 
     return x;
 }
 
 //------------------------------------------------------------------------------
 // Name: simplify
 //------------------------------------------------------------------------------
 void KNumber::simplify() {
 
     if(value_->is_integer()) {
 
         if(detail::knumber_integer *const p = dynamic_cast<detail::knumber_integer *>(value_)) {
             // NO-OP
             Q_UNUSED(p);
         } else if(detail::knumber_float *const p = dynamic_cast<detail::knumber_float *>(value_)) {
             detail::knumber_base *v = new detail::knumber_integer(p);
             qSwap(v, value_);
             delete v;
         } else if(detail::knumber_fraction *const p = dynamic_cast<detail::knumber_fraction *>(value_)) {
             detail::knumber_base *v = new detail::knumber_integer(p);
             qSwap(v, value_);
             delete v;
         } else if(detail::knumber_error *const p = dynamic_cast<detail::knumber_error *>(value_)) {
             // NO-OP
             Q_UNUSED(p);
         } else {
             Q_ASSERT(0);
         }
     }
 }
 
 //------------------------------------------------------------------------------
 // Name: operator+=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator+=(const KNumber &rhs) {
     value_ = value_->add(rhs.value_);
     simplify();
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator-=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator-=(const KNumber &rhs) {
     value_ = value_->sub(rhs.value_);
     simplify();
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator*=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator*=(const KNumber &rhs) {
     value_ = value_->mul(rhs.value_);
     simplify();
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator/=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator/=(const KNumber &rhs) {
 
     // Fix for bug #330577, x /0  is undefined, not infinity
     // Also indirectly fixes bug #329897, tan(90) is undefined, not infinity
     if(rhs == Zero) {
         *this = NaN;
         return *this;
     }
 
     value_ = value_->div(rhs.value_);
     simplify();
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator%=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator%=(const KNumber &rhs) {
     value_ = value_->mod(rhs.value_);
     simplify();
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator&=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator&=(const KNumber &rhs) {
     value_ = value_->bitwise_and(rhs.value_);
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator|=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator|=(const KNumber &rhs) {
     value_ = value_->bitwise_or(rhs.value_);
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator^=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator^=(const KNumber &rhs) {
     value_ = value_->bitwise_xor(rhs.value_);
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator<<
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator<<=(const KNumber &rhs) {
     value_ = value_->bitwise_shift(rhs.value_);
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator>>=
 //------------------------------------------------------------------------------
 KNumber &KNumber::operator>>=(const KNumber &rhs) {
     const KNumber rhs_neg(-rhs);
     value_ = value_->bitwise_shift(rhs_neg.value_);
     return *this;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator-
 //------------------------------------------------------------------------------
 KNumber KNumber::operator-() const {
     KNumber x(*this);
     x.value_ = x.value_->neg();
     return x;
 }
 
 //------------------------------------------------------------------------------
 // Name: operator~
 //------------------------------------------------------------------------------
 KNumber KNumber::operator~() const {
     KNumber x(*this);
     x.value_ = x.value_->cmp();
     return x;
 }
 
 //------------------------------------------------------------------------------
 // Name: toQString
 //------------------------------------------------------------------------------
 QString KNumber::toQString(int width, int precision) const {
 
     if(value_->is_zero()) {
         return QStringLiteral("0");
     }
 
     QString s;
 
     if(detail::knumber_integer *const p = dynamic_cast<detail::knumber_integer *>(value_)) {
         if(width > 0) {
             s = detail::knumber_float(p).toString(width);
         } else {
             s = value_->toString(width);
         }
     } else if(detail::knumber_float *const p = dynamic_cast<detail::knumber_float *>(value_)) {
         if(width > 0) {
             s = value_->toString(width);
         } else {
             s = value_->toString(3 * mpf_get_default_prec() / 10);
         }
     } else if(detail::knumber_fraction *const p = dynamic_cast<detail::knumber_fraction *>(value_)) {
         s = value_->toString(width);
     } else {
         return value_->toString(width);
     }
 
     // now do some rounding to make sure things are displayed reasonably
     if (precision >= 0) {
         return round(s, precision);
     } else {
         return s;
     }
 }
 
 QString KNumber::toBinaryString(int precision) const
 {
     return value_->toBinaryString(precision);
 }
 QString KNumber::toHexString(int precision) const
 {
     return value_->toHexString(precision);
 }
 //------------------------------------------------------------------------------
 // Name: toUint64
 //------------------------------------------------------------------------------
 quint64 KNumber::toUint64() const {
     return value_->toUint64();
 }
 
 //------------------------------------------------------------------------------
 // Name: toInt64
 //------------------------------------------------------------------------------
 qint64 KNumber::toInt64() const {
     return value_->toInt64();
 }
 
 //------------------------------------------------------------------------------
 // Name: abs
 //------------------------------------------------------------------------------
 KNumber KNumber::abs() const {
     KNumber z(*this);
     z.value_ = z.value_->abs();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: cbrt
 //------------------------------------------------------------------------------
 KNumber KNumber::cbrt() const {
     KNumber z(*this);
     z.value_ = z.value_->cbrt();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: sqrt
 //------------------------------------------------------------------------------
 KNumber KNumber::sqrt() const {
     KNumber z(*this);
     z.value_ = z.value_->sqrt();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: pow
 //------------------------------------------------------------------------------
 KNumber KNumber::pow(const KNumber &x) const {
 
     // Fix for bug #330711 (pow(0, -x) was causing crashes
     // Fix for bug #330597 (pow(0,0) was 1 now it is NaN
     // Thanks to Raushan Kumar for identifying the issue and submitting
     // patches
     if(*this == Zero && x <= Zero) {
         return NaN;
     }
 
     // if the LHS is a special then we can use this function
     // no matter what, cause the result is a special too
     if(!dynamic_cast<detail::knumber_error *>(value_)) {
         // number much bigger than this tend to crash GMP with
         // an abort
         if(x > KNumber(QStringLiteral("1000000000"))) {
             return PosInfinity;
         }
     }
 
     KNumber z(*this);
     z.value_ = z.value_->pow(x.value_);
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: sin
 //------------------------------------------------------------------------------
 KNumber KNumber::sin() const {
     KNumber z(*this);
     z.value_ = z.value_->sin();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: cos
 //------------------------------------------------------------------------------
 KNumber KNumber::cos() const {
     KNumber z(*this);
     z.value_ = z.value_->cos();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: tan
 //------------------------------------------------------------------------------
 KNumber KNumber::tan() const {
     KNumber z(*this);
     z.value_ = z.value_->tan();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: tgamma
 //------------------------------------------------------------------------------
 KNumber KNumber::tgamma() const {
     KNumber z(*this);
     if(z > KNumber(QStringLiteral("10000000000"))) {
         return PosInfinity;
     }
     z.value_ = z.value_->tgamma();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: asin
 //------------------------------------------------------------------------------
 KNumber KNumber::asin() const {
     KNumber z(*this);
     z.value_ = z.value_->asin();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: acos
 //------------------------------------------------------------------------------
 KNumber KNumber::acos() const {
     KNumber z(*this);
     z.value_ = z.value_->acos();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: atan
 //------------------------------------------------------------------------------
 KNumber KNumber::atan() const {
     KNumber z(*this);
     z.value_ = z.value_->atan();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: sinh
 //------------------------------------------------------------------------------
 KNumber KNumber::sinh() const {
     KNumber z(*this);
     z.value_ = z.value_->sinh();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: cosh
 //------------------------------------------------------------------------------
 KNumber KNumber::cosh() const {
     KNumber z(*this);
     z.value_ = z.value_->cosh();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: tanh
 //------------------------------------------------------------------------------
 KNumber KNumber::tanh() const {
     KNumber z(*this);
     z.value_ = z.value_->tanh();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: asinh
 //------------------------------------------------------------------------------
 KNumber KNumber::asinh() const {
     KNumber z(*this);
     z.value_ = z.value_->asinh();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: acosh
 //------------------------------------------------------------------------------
 KNumber KNumber::acosh() const {
     KNumber z(*this);
     z.value_ = z.value_->acosh();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: atanh
 //------------------------------------------------------------------------------
 KNumber KNumber::atanh() const {
     KNumber z(*this);
     z.value_ = z.value_->atanh();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: factorial
 //------------------------------------------------------------------------------
 KNumber KNumber::factorial() const {
     KNumber z(*this);
 
     // number much bigger than this tend to crash GMP with
     // an abort
     if(z > KNumber(QStringLiteral("10000000000"))) {
         return PosInfinity;
     }
 
     z.value_ = z.value_->factorial();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: log2
 //------------------------------------------------------------------------------
 KNumber KNumber::log2() const {
     KNumber z(*this);
     z.value_ = z.value_->log2();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: log10
 //------------------------------------------------------------------------------
 KNumber KNumber::log10() const {
     KNumber z(*this);
     z.value_ = z.value_->log10();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: ln
 //------------------------------------------------------------------------------
 KNumber KNumber::ln() const {
     KNumber z(*this);
     z.value_ = z.value_->ln();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: floor
 //------------------------------------------------------------------------------
 KNumber KNumber::floor() const {
     KNumber z(*this);
     z.value_ = z.value_->floor();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: ceil
 //------------------------------------------------------------------------------
 KNumber KNumber::ceil() const {
     KNumber z(*this);
     z.value_ = z.value_->ceil();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: exp2
 //------------------------------------------------------------------------------
 KNumber KNumber::exp2() const {
     KNumber z(*this);
     z.value_ = z.value_->exp2();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: exp10
 //------------------------------------------------------------------------------
 KNumber KNumber::exp10() const {
     KNumber z(*this);
     z.value_ = z.value_->exp10();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: exp
 //------------------------------------------------------------------------------
 KNumber KNumber::exp() const {
     KNumber z(*this);
     z.value_ = z.value_->exp();
     z.simplify();
     return z;
 }
 
 //------------------------------------------------------------------------------
 // Name: bin
 //------------------------------------------------------------------------------
 KNumber KNumber::bin(const KNumber &x) const {
     KNumber z(*this);
     z.value_ = z.value_->bin(x.value_);
     z.simplify();
     return z;
 }