// instead of in some header file where it would propagate to other parts.
// Also, we only need a subset of CLN, so we don't include the complete cln.h:
#ifdef HAVE_CLN_CLN_H
+#include <cln/cl_output.h>
#include <cln/cl_integer_io.h>
#include <cln/cl_integer_ring.h>
#include <cln/cl_rational_io.h>
#include <cln/cl_complex_ring.h>
#include <cln/cl_numtheory.h>
#else // def HAVE_CLN_CLN_H
+#include <cl_output.h>
#include <cl_integer_io.h>
#include <cl_integer_ring.h>
#include <cl_rational_io.h>
{
debugmsg("numeric default constructor", LOGLEVEL_CONSTRUCT);
value = new cl_N;
- *value=cl_I(0);
+ *value = cl_I(0);
calchash();
- setflag(status_flags::evaluated|
+ setflag(status_flags::evaluated |
+ status_flags::expanded |
status_flags::hash_calculated);
}
{
debugmsg("numeric constructor from int",LOGLEVEL_CONSTRUCT);
// 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 behaviour of the cl_I-ctor, which
// emphasizes efficiency:
value = new cl_I((long) i);
calchash();
{
debugmsg("numeric constructor from uint",LOGLEVEL_CONSTRUCT);
// 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 behaviour of the cl_I-ctor, which
// emphasizes efficiency:
value = new cl_I((unsigned long)i);
calchash();
return new numeric(*this);
}
+
+/** Helper function to print a real number in a nicer way than is CLN's
+ * default. Instead of printing 42.0L0 this just prints 42.0 to ostream os
+ * and instead of 3.99168L7 it prints 3.99168E7. This is fine in GiNaC as
+ * long as it only uses cl_LF and no other floating point types.
+ *
+ * @see numeric::print() */
+void print_real_number(ostream & os, const cl_R & num)
+{
+ cl_print_flags ourflags;
+ if (::instanceof(num, ::cl_RA_ring)) {
+ // case 1: integer or rational, nothing special to do:
+ ::print_real(os, ourflags, num);
+ } else {
+ // case 2: float
+ // make CLN believe this number has default_float_format, so it prints
+ // 'E' as exponent marker instead of 'L':
+ ourflags.default_float_format = ::cl_float_format(The(cl_F)(num));
+ ::print_real(os, ourflags, num);
+ }
+ return;
+}
+
+/** This method adds to the output so it blends more consistently together
+ * with the other routines and produces something compatible to ginsh input.
+ *
+ * @see print_real_number() */
void numeric::print(ostream & os, unsigned upper_precedence) const
{
- // The method print adds to the output so it blends more consistently
- // together with the other routines and produces something compatible to
- // ginsh input.
debugmsg("numeric print", LOGLEVEL_PRINT);
if (this->is_real()) {
// case 1, real: x or -x
- if ((precedence<=upper_precedence) && (!this->is_pos_integer())) {
- os << "(" << *value << ")";
+ if ((precedence<=upper_precedence) && (!this->is_nonneg_integer())) {
+ os << "(";
+ print_real_number(os, The(cl_R)(*value));
+ os << ")";
} else {
- os << *value;
+ print_real_number(os, The(cl_R)(*value));
}
} else {
// case 2, imaginary: y*I or -y*I
if (::imagpart(*value) == -1) {
os << "(-I)";
} else {
- os << "(" << ::imagpart(*value) << "*I)";
+ os << "(";
+ print_real_number(os, The(cl_R)(::imagpart(*value)));
+ os << "*I)";
}
} else {
if (::imagpart(*value) == 1) {
if (::imagpart (*value) == -1) {
os << "-I";
} else {
- os << ::imagpart(*value) << "*I";
+ print_real_number(os, The(cl_R)(::imagpart(*value)));
+ os << "*I";
}
}
}
} else {
// case 3, complex: x+y*I or x-y*I or -x+y*I or -x-y*I
- if (precedence <= upper_precedence) os << "(";
- os << ::realpart(*value);
+ if (precedence <= upper_precedence)
+ os << "(";
+ print_real_number(os, The(cl_R)(::realpart(*value)));
if (::imagpart(*value) < 0) {
if (::imagpart(*value) == -1) {
os << "-I";
} else {
- os << ::imagpart(*value) << "*I";
+ print_real_number(os, The(cl_R)(::imagpart(*value)));
+ os << "*I";
}
} else {
if (::imagpart(*value) == 1) {
os << "+I";
} else {
- os << "+" << ::imagpart(*value) << "*I";
+ os << "+";
+ print_real_number(os, The(cl_R)(::imagpart(*value)));
+ os << "*I";
}
}
- if (precedence <= upper_precedence) os << ")";
+ if (precedence <= upper_precedence)
+ os << ")";
}
}
}
case info_flags::negative:
return is_negative();
case info_flags::nonnegative:
- return compare(_num0())>=0;
+ return !is_negative();
case info_flags::posint:
return is_pos_integer();
case info_flags::negint:
- return is_integer() && (compare(_num0())<0);
+ return is_integer() && is_negative();
case info_flags::nonnegint:
return is_nonneg_integer();
case info_flags::even:
numeric numeric::power(const numeric & other) const
{
- static const numeric * _num1p=&_num1();
+ static const numeric * _num1p = &_num1();
if (&other==_num1p)
return *this;
if (::zerop(*value)) {
if (::zerop(*other.value))
throw (std::domain_error("numeric::eval(): pow(0,0) is undefined"));
- else if (other.is_real() && !::plusp(::realpart(*other.value)))
+ else if (::zerop(::realpart(*other.value)))
+ throw (std::domain_error("numeric::eval(): pow(0,I) is undefined"));
+ else if (::minusp(::realpart(*other.value)))
throw (std::overflow_error("numeric::eval(): division by zero"));
else
return _num0();
if (::zerop(*value)) {
if (::zerop(*other.value))
throw (std::domain_error("numeric::eval(): pow(0,0) is undefined"));
- else if (other.is_real() && !::plusp(::realpart(*other.value)))
+ else if (::zerop(::realpart(*other.value)))
+ throw (std::domain_error("numeric::eval(): pow(0,I) is undefined"));
+ else if (::minusp(::realpart(*other.value)))
throw (std::overflow_error("numeric::eval(): division by zero"));
else
return _num0();
/** True if object is a non-complex integer. */
bool numeric::is_integer(void) const
{
- return ::instanceof(*value, cl_I_ring); // -> CLN
+ return ::instanceof(*value, ::cl_I_ring); // -> CLN
}
/** True if object is an exact integer greater than zero. */
* (denominator may be unity). */
bool numeric::is_rational(void) const
{
- return ::instanceof(*value, cl_RA_ring); // -> CLN
+ return ::instanceof(*value, ::cl_RA_ring); // -> CLN
}
/** True if object is a real integer, rational or float (but not complex). */
bool numeric::is_real(void) const
{
- return ::instanceof(*value, cl_R_ring); // -> CLN
+ return ::instanceof(*value, ::cl_R_ring); // -> CLN
}
bool numeric::operator==(const numeric & other) const
* of the form a+b*I, where a and b are integers. */
bool numeric::is_cinteger(void) const
{
- if (::instanceof(*value, cl_I_ring))
+ if (::instanceof(*value, ::cl_I_ring))
return true;
else if (!this->is_real()) { // complex case, handle n+m*I
- if (::instanceof(::realpart(*value), cl_I_ring) &&
- ::instanceof(::imagpart(*value), cl_I_ring))
+ if (::instanceof(::realpart(*value), ::cl_I_ring) &&
+ ::instanceof(::imagpart(*value), ::cl_I_ring))
return true;
}
return false;
* (denominator may be unity). */
bool numeric::is_crational(void) const
{
- if (::instanceof(*value, cl_RA_ring))
+ if (::instanceof(*value, ::cl_RA_ring))
return true;
else if (!this->is_real()) { // complex case, handle Q(i):
- if (::instanceof(::realpart(*value), cl_RA_ring) &&
- ::instanceof(::imagpart(*value), cl_RA_ring))
+ if (::instanceof(::realpart(*value), ::cl_RA_ring) &&
+ ::instanceof(::imagpart(*value), ::cl_RA_ring))
return true;
}
return false;
}
/** Real part of a number. */
-numeric numeric::real(void) const
+const numeric numeric::real(void) const
{
return numeric(::realpart(*value)); // -> CLN
}
/** Imaginary part of a number. */
-numeric numeric::imag(void) const
+const numeric numeric::imag(void) const
{
return numeric(::imagpart(*value)); // -> CLN
}
* numerator of complex if real and imaginary part are both rational numbers
* (i.e numer(4/3+5/6*I) == 8+5*I), the number carrying the sign in all other
* cases. */
-numeric numeric::numer(void) const
+const numeric numeric::numer(void) const
{
if (this->is_integer()) {
return numeric(*this);
}
#ifdef SANE_LINKER
- else if (::instanceof(*value, cl_RA_ring)) {
+ else if (::instanceof(*value, ::cl_RA_ring)) {
return numeric(::numerator(The(cl_RA)(*value)));
}
else if (!this->is_real()) { // complex case, handle Q(i):
cl_R r = ::realpart(*value);
cl_R i = ::imagpart(*value);
- if (::instanceof(r, cl_I_ring) && ::instanceof(i, cl_I_ring))
+ if (::instanceof(r, ::cl_I_ring) && ::instanceof(i, ::cl_I_ring))
return numeric(*this);
- if (::instanceof(r, cl_I_ring) && ::instanceof(i, cl_RA_ring))
+ if (::instanceof(r, ::cl_I_ring) && ::instanceof(i, ::cl_RA_ring))
return numeric(::complex(r*::denominator(The(cl_RA)(i)), ::numerator(The(cl_RA)(i))));
- if (::instanceof(r, cl_RA_ring) && ::instanceof(i, cl_I_ring))
+ if (::instanceof(r, ::cl_RA_ring) && ::instanceof(i, ::cl_I_ring))
return numeric(::complex(::numerator(The(cl_RA)(r)), i*::denominator(The(cl_RA)(r))));
- if (::instanceof(r, cl_RA_ring) && ::instanceof(i, cl_RA_ring)) {
+ if (::instanceof(r, ::cl_RA_ring) && ::instanceof(i, ::cl_RA_ring)) {
cl_I s = ::lcm(::denominator(The(cl_RA)(r)), ::denominator(The(cl_RA)(i)));
return numeric(::complex(::numerator(The(cl_RA)(r))*(exquo(s,::denominator(The(cl_RA)(r)))),
::numerator(The(cl_RA)(i))*(exquo(s,::denominator(The(cl_RA)(i))))));
}
}
#else
- else if (instanceof(*value, cl_RA_ring)) {
+ else if (instanceof(*value, ::cl_RA_ring)) {
return numeric(TheRatio(*value)->numerator);
}
else if (!this->is_real()) { // complex case, handle Q(i):
cl_R r = ::realpart(*value);
cl_R i = ::imagpart(*value);
- if (instanceof(r, cl_I_ring) && instanceof(i, cl_I_ring))
+ if (instanceof(r, ::cl_I_ring) && instanceof(i, ::cl_I_ring))
return numeric(*this);
- if (instanceof(r, cl_I_ring) && instanceof(i, cl_RA_ring))
+ if (instanceof(r, ::cl_I_ring) && instanceof(i, ::cl_RA_ring))
return numeric(::complex(r*TheRatio(i)->denominator, TheRatio(i)->numerator));
- if (instanceof(r, cl_RA_ring) && instanceof(i, cl_I_ring))
+ if (instanceof(r, ::cl_RA_ring) && instanceof(i, ::cl_I_ring))
return numeric(::complex(TheRatio(r)->numerator, i*TheRatio(r)->denominator));
- if (instanceof(r, cl_RA_ring) && instanceof(i, cl_RA_ring)) {
+ if (instanceof(r, ::cl_RA_ring) && instanceof(i, ::cl_RA_ring)) {
cl_I s = ::lcm(TheRatio(r)->denominator, TheRatio(i)->denominator);
return numeric(::complex(TheRatio(r)->numerator*(exquo(s,TheRatio(r)->denominator)),
TheRatio(i)->numerator*(exquo(s,TheRatio(i)->denominator))));
/** Denominator. Computes the denominator of rational numbers, common integer
* denominator of complex if real and imaginary part are both rational numbers
* (i.e denom(4/3+5/6*I) == 6), one in all other cases. */
-numeric numeric::denom(void) const
+const numeric numeric::denom(void) const
{
if (this->is_integer()) {
return _num1();
}
#ifdef SANE_LINKER
- if (instanceof(*value, cl_RA_ring)) {
+ if (instanceof(*value, ::cl_RA_ring)) {
return numeric(::denominator(The(cl_RA)(*value)));
}
if (!this->is_real()) { // complex case, handle Q(i):
cl_R r = ::realpart(*value);
cl_R i = ::imagpart(*value);
- if (::instanceof(r, cl_I_ring) && ::instanceof(i, cl_I_ring))
+ if (::instanceof(r, ::cl_I_ring) && ::instanceof(i, ::cl_I_ring))
return _num1();
- if (::instanceof(r, cl_I_ring) && ::instanceof(i, cl_RA_ring))
+ if (::instanceof(r, ::cl_I_ring) && ::instanceof(i, ::cl_RA_ring))
return numeric(::denominator(The(cl_RA)(i)));
- if (::instanceof(r, cl_RA_ring) && ::instanceof(i, cl_I_ring))
+ if (::instanceof(r, ::cl_RA_ring) && ::instanceof(i, ::cl_I_ring))
return numeric(::denominator(The(cl_RA)(r)));
- if (::instanceof(r, cl_RA_ring) && ::instanceof(i, cl_RA_ring))
+ if (::instanceof(r, ::cl_RA_ring) && ::instanceof(i, ::cl_RA_ring))
return numeric(::lcm(::denominator(The(cl_RA)(r)), ::denominator(The(cl_RA)(i))));
}
#else
- if (instanceof(*value, cl_RA_ring)) {
+ if (instanceof(*value, ::cl_RA_ring)) {
return numeric(TheRatio(*value)->denominator);
}
if (!this->is_real()) { // complex case, handle Q(i):
cl_R r = ::realpart(*value);
cl_R i = ::imagpart(*value);
- if (instanceof(r, cl_I_ring) && instanceof(i, cl_I_ring))
+ if (instanceof(r, ::cl_I_ring) && instanceof(i, ::cl_I_ring))
return _num1();
- if (instanceof(r, cl_I_ring) && instanceof(i, cl_RA_ring))
+ if (instanceof(r, ::cl_I_ring) && instanceof(i, ::cl_RA_ring))
return numeric(TheRatio(i)->denominator);
- if (instanceof(r, cl_RA_ring) && instanceof(i, cl_I_ring))
+ if (instanceof(r, ::cl_RA_ring) && instanceof(i, ::cl_I_ring))
return numeric(TheRatio(r)->denominator);
- if (instanceof(r, cl_RA_ring) && instanceof(i, cl_RA_ring))
+ if (instanceof(r, ::cl_RA_ring) && instanceof(i, ::cl_RA_ring))
return numeric(::lcm(TheRatio(r)->denominator, TheRatio(i)->denominator));
}
#endif // def SANE_LINKER
return _num0();
// Until somebody has the Blues and comes up with a much better idea and
// codes it (preferably in CLN) we make this a remembering function which
- // computes its results using the formula
+ // computes its results using the defining formula
// B(nn) == - 1/(nn+1) * sum_{k=0}^{nn-1}(binomial(nn+1,k)*B(k))
// whith B(0) == 1.
+ // Be warned, though: the Bernoulli numbers are probably computationally
+ // very expensive anyhow and you shouldn't expect miracles to happen.
static vector<numeric> results;
static int highest_result = -1;
int n = nn.sub(_num2()).div(_num2()).to_int();
* @exception range_error (argument must be an integer) */
const numeric fibonacci(const numeric & n)
{
- if (!n.is_integer()) {
+ if (!n.is_integer())
throw (std::range_error("numeric::fibonacci(): argument must be integer"));
- }
- // For positive arguments compute the nearest integer to
- // ((1+sqrt(5))/2)^n/sqrt(5). For negative arguments, apply an additional
- // sign. Note that we are falling back to longs, but this should suffice
- // for all times.
- int sig = 1;
- const long nn = ::abs(n.to_double());
- if (n.is_negative() && n.is_even())
- sig =-1;
+ // The following addition formula holds:
+ // F(n+m) = F(m-1)*F(n) + F(m)*F(n+1) for m >= 1, n >= 0.
+ // (Proof: For fixed m, the LHS and the RHS satisfy the same recurrence
+ // w.r.t. n, and the initial values (n=0, n=1) agree. Hence all values
+ // agree.)
+ // Replace m by m+1:
+ // F(n+m+1) = F(m)*F(n) + F(m+1)*F(n+1) for m >= 0, n >= 0
+ // Now put in m = n, to get
+ // F(2n) = (F(n+1)-F(n))*F(n) + F(n)*F(n+1) = F(n)*(2*F(n+1) - F(n))
+ // F(2n+1) = F(n)^2 + F(n+1)^2
+ // hence
+ // F(2n+2) = F(n+1)*(2*F(n) + F(n+1))
+ if (n.is_zero())
+ return _num0();
+ if (n.is_negative())
+ if (n.is_even())
+ return -fibonacci(-n);
+ else
+ return fibonacci(-n);
- // Need a precision of ((1+sqrt(5))/2)^-n.
- cl_float_format_t prec = ::cl_float_format((int)(0.208987641*nn+5));
- cl_R sqrt5 = ::sqrt(::cl_float(5,prec));
- cl_R phi = (1+sqrt5)/2;
- return numeric(::round1(::expt(phi,nn)/sqrt5)*sig);
+ cl_I u(0);
+ cl_I v(1);
+ cl_I m = The(cl_I)(*n.value) >> 1L; // floor(n/2);
+ for (uintL bit=::integer_length(m); bit>0; --bit) {
+ // Since a squaring is cheaper than a multiplication, better use
+ // three squarings instead of one multiplication and two squarings.
+ cl_I u2 = ::square(u);
+ cl_I v2 = ::square(v);
+ if (::logbitp(bit-1, m)) {
+ v = ::square(u + v) - u2;
+ u = u2 + v2;
+ } else {
+ u = v2 - ::square(v - u);
+ v = u2 + v2;
+ }
+ }
+ if (n.is_even())
+ // Here we don't use the squaring formula because one multiplication
+ // is cheaper than two squarings.
+ return u * ((v << 1) - u);
+ else
+ return ::square(u) + ::square(v);
}
git://www.ginac.de / ginac.git / blobdiff