* of special functions or implement the interface to the bignum package. */
/*
- * GiNaC Copyright (C) 1999-2015 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2020 Johannes Gutenberg University Mainz, Germany
*
* 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
#include "ex.h"
#include "operators.h"
#include "archive.h"
-#include "tostring.h"
#include "utils.h"
#include <limits>
numeric::numeric(int i)
{
// Not the whole int-range is available if we don't cast to long
- // first. This is due to the behaviour of the cl_I-ctor, which
+ // first. This is due to the behavior of the cl_I-ctor, which
// emphasizes efficiency. However, if the integer is small enough
// we save space and dereferences by using an immediate type.
// (C.f. <cln/object.h>)
numeric::numeric(unsigned int i)
{
// Not the whole uint-range is available if we don't cast to ulong
- // first. This is due to the behaviour of the cl_I-ctor, which
+ // first. This is due to the behavior of the cl_I-ctor, which
// emphasizes efficiency. However, if the integer is small enough
// we save space and dereferences by using an immediate type.
// (C.f. <cln/object.h>)
setflag(status_flags::evaluated | status_flags::expanded);
}
+numeric::numeric(long long i)
+{
+ value = cln::cl_I(i);
+ setflag(status_flags::evaluated | status_flags::expanded);
+}
+
+numeric::numeric(unsigned long long i)
+{
+ value = cln::cl_I(i);
+ setflag(status_flags::evaluated | status_flags::expanded);
+}
/** Constructor for rational numerics a/b.
*
// E to lower case
term = term.replace(term.find("E"),1,"e");
// append _<Digits> to term
- term += "_" + ToString((unsigned)Digits);
+ term += "_" + std::to_string((unsigned)Digits);
// construct float using cln::cl_F(const char *) ctor.
if (imaginary)
ctorval = ctorval + cln::complex(cln::cl_I(0),cln::cl_F(term.c_str()));
// Rational number
const cln::cl_I numer = cln::numerator(cln::the<cln::cl_RA>(x));
const cln::cl_I denom = cln::denominator(cln::the<cln::cl_RA>(x));
- if (cln::plusp(x) > 0) {
+ if (cln::plusp(x)) {
c.s << "(";
print_integer_csrc(c, numer);
} else {
/**
* @brief Check if CLN integer can be converted into int
*
- * @sa http://www.ginac.de/pipermail/cln-list/2006-October/000248.html
+ * @sa https://www.ginac.de/pipermail/cln-list/2006-October/000248.html
*/
template<>
inline bool coerce<int, cln::cl_I>(int& dst, const cln::cl_I& arg)
if (coerce(dst, cln::the<cln::cl_I>(x))) {
// can be converted to native int
if (dst < 0)
- c.s << "(-" << dst << ")";
+ c.s << '(' << dst << ')';
else
c.s << dst;
} else {
return is_odd();
case info_flags::prime:
return is_prime();
- case info_flags::algebraic:
- return !is_real();
}
return false;
}
/** Evaluation of numbers doesn't do anything at all. */
-ex numeric::eval(int level) const
+ex numeric::eval() const
{
- // Warning: if this is ever gonna do something, the ex ctors from all kinds
- // of numbers should be checking for status_flags::evaluated.
return this->hold();
}
* currently set. In case the object already was a floating point number the
* precision is trimmed to match the currently set default.
*
- * @param level ignored, only needed for overriding basic::evalf.
* @return an ex-handle to a numeric. */
-ex numeric::evalf(int level) const
+ex numeric::evalf() const
{
- // level can safely be discarded for numeric objects.
return numeric(cln::cl_float(1.0, cln::default_float_format) * value);
}
return other;
else if (&other==_num0_p)
return *this;
-
- return static_cast<const numeric &>((new numeric(value + other.value))->
- setflag(status_flags::dynallocated));
+
+ return dynallocate<numeric>(value + other.value);
}
// hack is supposed to keep the number of distinct numeric objects low.
if (&other==_num0_p || cln::zerop(other.value))
return *this;
-
- return static_cast<const numeric &>((new numeric(value - other.value))->
- setflag(status_flags::dynallocated));
+
+ return dynallocate<numeric>(value - other.value);
}
else if (&other==_num1_p)
return *this;
- return static_cast<const numeric &>((new numeric(value * other.value))->
- setflag(status_flags::dynallocated));
+ return dynallocate<numeric>(value * other.value);
}
return *this;
if (cln::zerop(cln::the<cln::cl_N>(other.value)))
throw std::overflow_error("division by zero");
- return static_cast<const numeric &>((new numeric(value / other.value))->
- setflag(status_flags::dynallocated));
+
+ return dynallocate<numeric>(value / other.value);
}
else
return *_num0_p;
}
- return static_cast<const numeric &>((new numeric(cln::expt(value, other.value)))->
- setflag(status_flags::dynallocated));
+
+ return dynallocate<numeric>(cln::expt(value, other.value));
}
std::vector<cln::cl_N> *current_vector;
};
-std::vector<cln::cl_N>* lanczos_coeffs::coeffs = 0;
+std::vector<cln::cl_N>* lanczos_coeffs::coeffs = nullptr;
bool lanczos_coeffs::sufficiently_accurate(int digits)
{ if (digits<=20) {
coeffs[3].swap(coeffs_120);
}
-static const cln::float_format_t guess_precision(const cln::cl_N& x)
+static cln::float_format_t guess_precision(const cln::cl_N& x)
{
cln::float_format_t prec = cln::default_float_format;
if (!instanceof(realpart(x), cln::cl_RA_ring))
results.reserve(n/2);
for (unsigned p=next_r; p<=n; p+=2) {
- cln::cl_I c = 1; // seed for binonmial coefficients
+ cln::cl_I c = 1; // seed for binomial coefficients
cln::cl_RA b = cln::cl_RA(p-1)/-2;
// The CLN manual says: "The conversion from `unsigned int' works only
// if the argument is < 2^29" (This is for 32 Bit machines. More
git://www.ginac.de / ginac.git / blobdiff