case 'N': // Ordinary number
case 'R': // Integer-decoded real number
s >> re.sign >> re.mantissa >> re.exponent;
- *value = re.sign * re.mantissa * expt(cl_float(2.0, cl_default_float_format), re.exponent);
+ *value = re.sign * re.mantissa * ::expt(cl_float(2.0, cl_default_float_format), re.exponent);
break;
case 'C': // Integer-decoded complex number
s >> re.sign >> re.mantissa >> re.exponent;
s >> im.sign >> im.mantissa >> im.exponent;
- *value = complex(re.sign * re.mantissa * expt(cl_float(2.0, cl_default_float_format), re.exponent),
- im.sign * im.mantissa * expt(cl_float(2.0, cl_default_float_format), im.exponent));
+ *value = ::complex(re.sign * re.mantissa * ::expt(cl_float(2.0, cl_default_float_format), re.exponent),
+ im.sign * im.mantissa * ::expt(cl_float(2.0, cl_default_float_format), im.exponent));
break;
default: // Ordinary number
s.putback(c);
switch (c) {
case 'R': // Integer-decoded real number
f >> re.sign >> re.mantissa >> re.exponent;
- *value = re.sign * re.mantissa * expt(cl_float(2.0, cl_default_float_format), re.exponent);
+ *value = re.sign * re.mantissa * ::expt(cl_float(2.0, cl_default_float_format), re.exponent);
break;
case 'C': // Integer-decoded complex number
f >> re.sign >> re.mantissa >> re.exponent;
f >> im.sign >> im.mantissa >> im.exponent;
- *value = complex(re.sign * re.mantissa * expt(cl_float(2.0, cl_default_float_format), re.exponent),
- im.sign * im.mantissa * expt(cl_float(2.0, cl_default_float_format), im.exponent));
+ *value = ::complex(re.sign * re.mantissa * ::expt(cl_float(2.0, cl_default_float_format), re.exponent),
+ im.sign * im.mantissa * ::expt(cl_float(2.0, cl_default_float_format), im.exponent));
break;
default: // Ordinary number
f.putback(c);
#ifdef HAVE_SSTREAM
// Write number as string
ostringstream s;
- if (is_crational())
+ if (this->is_crational())
s << *value;
else {
// Non-rational numbers are written in an integer-decoded format
// to preserve the precision
- if (is_real()) {
+ if (this->is_real()) {
cl_idecoded_float re = integer_decode_float(The(cl_F)(*value));
s << "R";
s << re.sign << " " << re.mantissa << " " << re.exponent;
} else {
- cl_idecoded_float re = integer_decode_float(The(cl_F)(realpart(*value)));
- cl_idecoded_float im = integer_decode_float(The(cl_F)(imagpart(*value)));
+ cl_idecoded_float re = integer_decode_float(The(cl_F)(::realpart(*value)));
+ cl_idecoded_float im = integer_decode_float(The(cl_F)(::imagpart(*value)));
s << "C";
s << re.sign << " " << re.mantissa << " " << re.exponent << " ";
s << im.sign << " " << im.mantissa << " " << im.exponent;
// Write number as string
char buf[1024];
ostrstream f(buf, 1024);
- if (is_crational())
+ if (this->is_crational())
f << *value << ends;
else {
// Non-rational numbers are written in an integer-decoded format
// to preserve the precision
- if (is_real()) {
+ if (this->is_real()) {
cl_idecoded_float re = integer_decode_float(The(cl_F)(*value));
f << "R";
f << re.sign << " " << re.mantissa << " " << re.exponent << ends;
} else {
- cl_idecoded_float re = integer_decode_float(The(cl_F)(realpart(*value)));
- cl_idecoded_float im = integer_decode_float(The(cl_F)(imagpart(*value)));
+ cl_idecoded_float re = integer_decode_float(The(cl_F)(::realpart(*value)));
+ cl_idecoded_float im = integer_decode_float(The(cl_F)(::imagpart(*value)));
f << "C";
f << re.sign << " " << re.mantissa << " " << re.exponent << " ";
f << im.sign << " " << im.mantissa << " " << im.exponent << ends;
// together with the other routines and produces something compatible to
// ginsh input.
debugmsg("numeric print", LOGLEVEL_PRINT);
- if (is_real()) {
+ if (this->is_real()) {
// case 1, real: x or -x
- if ((precedence<=upper_precedence) && (!is_pos_integer())) {
+ if ((precedence<=upper_precedence) && (!this->is_pos_integer())) {
os << "(" << *value << ")";
} else {
os << *value;
}
} else {
// case 2, imaginary: y*I or -y*I
- if (realpart(*value) == 0) {
- if ((precedence<=upper_precedence) && (imagpart(*value) < 0)) {
- if (imagpart(*value) == -1) {
+ if (::realpart(*value) == 0) {
+ if ((precedence<=upper_precedence) && (::imagpart(*value) < 0)) {
+ if (::imagpart(*value) == -1) {
os << "(-I)";
} else {
- os << "(" << imagpart(*value) << "*I)";
+ os << "(" << ::imagpart(*value) << "*I)";
}
} else {
- if (imagpart(*value) == 1) {
+ if (::imagpart(*value) == 1) {
os << "I";
} else {
- if (imagpart (*value) == -1) {
+ if (::imagpart (*value) == -1) {
os << "-I";
} else {
- os << imagpart(*value) << "*I";
+ os << ::imagpart(*value) << "*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 (imagpart(*value) < 0) {
- if (imagpart(*value) == -1) {
+ os << ::realpart(*value);
+ if (::imagpart(*value) < 0) {
+ if (::imagpart(*value) == -1) {
os << "-I";
} else {
- os << imagpart(*value) << "*I";
+ os << ::imagpart(*value) << "*I";
}
} else {
- if (imagpart(*value) == 1) {
+ if (::imagpart(*value) == 1) {
os << "+I";
} else {
- os << "+" << imagpart(*value) << "*I";
+ os << "+" << ::imagpart(*value) << "*I";
}
}
if (precedence <= upper_precedence) os << ")";
debugmsg("numeric printraw", LOGLEVEL_PRINT);
os << "numeric(" << *value << ")";
}
+
+
void numeric::printtree(ostream & os, unsigned indent) const
{
debugmsg("numeric printtree", LOGLEVEL_PRINT);
<< ", flags=" << flags << endl;
}
+
void numeric::printcsrc(ostream & os, unsigned type, unsigned upper_precedence) const
{
debugmsg("numeric print csrc", LOGLEVEL_PRINT);
ios::fmtflags oldflags = os.flags();
os.setf(ios::scientific);
- if (is_rational() && !is_integer()) {
+ if (this->is_rational() && !this->is_integer()) {
if (compare(_num0()) > 0) {
os << "(";
if (type == csrc_types::ctype_cl_N)
os.flags(oldflags);
}
+
bool numeric::info(unsigned inf) const
{
switch (inf) {
return false;
}
+/** Disassemble real part and imaginary part to scan for the occurrence of a
+ * single number. Also handles the imaginary unit. It ignores the sign on
+ * both this and the argument, which may lead to what might appear as funny
+ * results: (2+I).has(-2) -> true. But this is consistent, since we also
+ * would like to have (-2+I).has(2) -> true and we want to think about the
+ * sign as a multiplicative factor. */
+bool numeric::has(const ex & other) const
+{
+ if (!is_exactly_of_type(*other.bp, numeric))
+ return false;
+ const numeric & o = static_cast<numeric &>(const_cast<basic &>(*other.bp));
+ if (this->is_equal(o) || this->is_equal(-o))
+ return true;
+ if (o.imag().is_zero()) // e.g. scan for 3 in -3*I
+ return (this->real().is_equal(o) || this->imag().is_equal(o) ||
+ this->real().is_equal(-o) || this->imag().is_equal(-o));
+ else {
+ if (o.is_equal(I)) // e.g scan for I in 42*I
+ return !this->is_real();
+ if (o.real().is_zero()) // e.g. scan for 2*I in 2*I+1
+ return (this->real().has(o*I) || this->imag().has(o*I) ||
+ this->real().has(-o*I) || this->imag().has(-o*I));
+ }
+ return false;
+}
+
+
+/** Evaluation of numbers doesn't do anything at all. */
ex numeric::eval(int level) const
{
// Warning: if this is ever gonna do something, the ex ctors from all kinds
return this->hold();
}
+
/** Cast numeric into a floating-point object. For example exact numeric(1) is
* returned as a 1.0000000000000000000000 and so on according to how Digits is
* currently set.
ex numeric::evalf(int level) const
{
// level can safely be discarded for numeric objects.
- return numeric(cl_float(1.0, cl_default_float_format) * (*value)); // -> CLN
+ return numeric(::cl_float(1.0, ::cl_default_float_format) * (*value)); // -> CLN
}
// protected
return _ex0();
}
+
int numeric::compare_same_type(const basic & other) const
{
GINAC_ASSERT(is_exactly_of_type(other, numeric));
return compare(o);
}
+
bool numeric::is_equal_same_type(const basic & other) const
{
GINAC_ASSERT(is_exactly_of_type(other,numeric));
const numeric *o = static_cast<const numeric *>(&other);
- return is_equal(*o);
+ return this->is_equal(*o);
}
/*
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 (other.is_real() && !::plusp(::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 (other.is_real() && !::plusp(::realpart(*other.value)))
throw (std::overflow_error("numeric::eval(): division by zero"));
else
return _num0();
* @see numeric::compare(const numeric & other) */
int numeric::csgn(void) const
{
- if (is_zero())
+ if (this->is_zero())
return 0;
- if (!::zerop(realpart(*value))) {
- if (::plusp(realpart(*value)))
+ if (!::zerop(::realpart(*value))) {
+ if (::plusp(::realpart(*value)))
return 1;
else
return -1;
} else {
- if (::plusp(imagpart(*value)))
+ if (::plusp(::imagpart(*value)))
return 1;
else
return -1;
int numeric::compare(const numeric & other) const
{
// Comparing two real numbers?
- if (is_real() && other.is_real())
+ if (this->is_real() && other.is_real())
// Yes, just compare them
return ::cl_compare(The(cl_R)(*value), The(cl_R)(*other.value));
else {
// No, first compare real parts
- cl_signean real_cmp = ::cl_compare(realpart(*value), realpart(*other.value));
+ cl_signean real_cmp = ::cl_compare(::realpart(*value), ::realpart(*other.value));
if (real_cmp)
return real_cmp;
- return ::cl_compare(imagpart(*value), imagpart(*other.value));
+ return ::cl_compare(::imagpart(*value), ::imagpart(*other.value));
}
}
/** True if object is not complex and greater than zero. */
bool numeric::is_positive(void) const
{
- if (is_real())
+ if (this->is_real())
return ::plusp(The(cl_R)(*value)); // -> CLN
return false;
}
/** True if object is not complex and less than zero. */
bool numeric::is_negative(void) const
{
- if (is_real())
+ if (this->is_real())
return ::minusp(The(cl_R)(*value)); // -> CLN
return false;
}
/** True if object is an exact integer greater than zero. */
bool numeric::is_pos_integer(void) const
{
- return (is_integer() && ::plusp(The(cl_I)(*value))); // -> CLN
+ return (this->is_integer() && ::plusp(The(cl_I)(*value))); // -> CLN
}
/** True if object is an exact integer greater or equal zero. */
bool numeric::is_nonneg_integer(void) const
{
- return (is_integer() && !::minusp(The(cl_I)(*value))); // -> CLN
+ return (this->is_integer() && !::minusp(The(cl_I)(*value))); // -> CLN
}
/** True if object is an exact even integer. */
bool numeric::is_even(void) const
{
- return (is_integer() && ::evenp(The(cl_I)(*value))); // -> CLN
+ return (this->is_integer() && ::evenp(The(cl_I)(*value))); // -> CLN
}
/** True if object is an exact odd integer. */
bool numeric::is_odd(void) const
{
- return (is_integer() && ::oddp(The(cl_I)(*value))); // -> CLN
+ return (this->is_integer() && ::oddp(The(cl_I)(*value))); // -> CLN
}
/** Probabilistic primality test.
* @return true if object is exact integer and prime. */
bool numeric::is_prime(void) const
{
- return (is_integer() && ::isprobprime(The(cl_I)(*value))); // -> CLN
+ return (this->is_integer() && ::isprobprime(The(cl_I)(*value))); // -> CLN
}
/** True if object is an exact rational number, may even be complex
{
if (::instanceof(*value, cl_I_ring))
return true;
- else if (!is_real()) { // complex case, handle n+m*I
- if (::instanceof(realpart(*value), cl_I_ring) &&
- ::instanceof(imagpart(*value), cl_I_ring))
+ else if (!this->is_real()) { // complex case, handle n+m*I
+ if (::instanceof(::realpart(*value), cl_I_ring) &&
+ ::instanceof(::imagpart(*value), cl_I_ring))
return true;
}
return false;
{
if (::instanceof(*value, cl_RA_ring))
return true;
- else if (!is_real()) { // complex case, handle Q(i):
- if (::instanceof(realpart(*value), cl_RA_ring) &&
- ::instanceof(imagpart(*value), cl_RA_ring))
+ else if (!this->is_real()) { // complex case, handle Q(i):
+ if (::instanceof(::realpart(*value), cl_RA_ring) &&
+ ::instanceof(::imagpart(*value), cl_RA_ring))
return true;
}
return false;
* @exception invalid_argument (complex inequality) */
bool numeric::operator<(const numeric & other) const
{
- if (is_real() && other.is_real())
- return (bool)(The(cl_R)(*value) < The(cl_R)(*other.value)); // -> CLN
+ if (this->is_real() && other.is_real())
+ return (The(cl_R)(*value) < The(cl_R)(*other.value)); // -> CLN
throw (std::invalid_argument("numeric::operator<(): complex inequality"));
return false; // make compiler shut up
}
* @exception invalid_argument (complex inequality) */
bool numeric::operator<=(const numeric & other) const
{
- if (is_real() && other.is_real())
- return (bool)(The(cl_R)(*value) <= The(cl_R)(*other.value)); // -> CLN
+ if (this->is_real() && other.is_real())
+ return (The(cl_R)(*value) <= The(cl_R)(*other.value)); // -> CLN
throw (std::invalid_argument("numeric::operator<=(): complex inequality"));
return false; // make compiler shut up
}
* @exception invalid_argument (complex inequality) */
bool numeric::operator>(const numeric & other) const
{
- if (is_real() && other.is_real())
- return (bool)(The(cl_R)(*value) > The(cl_R)(*other.value)); // -> CLN
+ if (this->is_real() && other.is_real())
+ return (The(cl_R)(*value) > The(cl_R)(*other.value)); // -> CLN
throw (std::invalid_argument("numeric::operator>(): complex inequality"));
return false; // make compiler shut up
}
* @exception invalid_argument (complex inequality) */
bool numeric::operator>=(const numeric & other) const
{
- if (is_real() && other.is_real())
- return (bool)(The(cl_R)(*value) >= The(cl_R)(*other.value)); // -> CLN
+ if (this->is_real() && other.is_real())
+ return (The(cl_R)(*value) >= The(cl_R)(*other.value)); // -> CLN
throw (std::invalid_argument("numeric::operator>=(): complex inequality"));
return false; // make compiler shut up
}
* You may also consider checking the range first. */
int numeric::to_int(void) const
{
- GINAC_ASSERT(is_integer());
+ GINAC_ASSERT(this->is_integer());
return ::cl_I_to_int(The(cl_I)(*value)); // -> CLN
}
* You may also consider checking the range first. */
long numeric::to_long(void) const
{
- GINAC_ASSERT(is_integer());
+ GINAC_ASSERT(this->is_integer());
return ::cl_I_to_long(The(cl_I)(*value)); // -> CLN
}
* if the number is really not complex before calling this method. */
double numeric::to_double(void) const
{
- GINAC_ASSERT(is_real());
- return ::cl_double_approx(realpart(*value)); // -> CLN
+ GINAC_ASSERT(this->is_real());
+ return ::cl_double_approx(::realpart(*value)); // -> CLN
}
/** Real part of a number. */
* cases. */
numeric numeric::numer(void) const
{
- if (is_integer()) {
+ if (this->is_integer()) {
return numeric(*this);
}
#ifdef SANE_LINKER
else if (::instanceof(*value, cl_RA_ring)) {
return numeric(::numerator(The(cl_RA)(*value)));
}
- else if (!is_real()) { // complex case, handle Q(i):
+ 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))
return numeric(*this);
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))));
+ 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))
- return numeric(complex(::numerator(The(cl_RA)(r)), i*::denominator(The(cl_RA)(r))));
+ 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)) {
- 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)))),
+ 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 if (instanceof(*value, cl_RA_ring)) {
return numeric(TheRatio(*value)->numerator);
}
- else if (!is_real()) { // complex case, handle Q(i):
- cl_R r = realpart(*value);
- cl_R i = imagpart(*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))
return numeric(*this);
if (instanceof(r, cl_I_ring) && instanceof(i, cl_RA_ring))
- return numeric(complex(r*TheRatio(i)->denominator, TheRatio(i)->numerator));
+ return numeric(::complex(r*TheRatio(i)->denominator, TheRatio(i)->numerator));
if (instanceof(r, cl_RA_ring) && instanceof(i, cl_I_ring))
- return numeric(complex(TheRatio(r)->numerator, i*TheRatio(r)->denominator));
+ return numeric(::complex(TheRatio(r)->numerator, i*TheRatio(r)->denominator));
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)),
+ 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))));
}
}
* (i.e denom(4/3+5/6*I) == 6), one in all other cases. */
numeric numeric::denom(void) const
{
- if (is_integer()) {
+ if (this->is_integer()) {
return _num1();
}
#ifdef SANE_LINKER
if (instanceof(*value, cl_RA_ring)) {
return numeric(::denominator(The(cl_RA)(*value)));
}
- if (!is_real()) { // complex case, handle Q(i):
- cl_R r = realpart(*value);
- cl_R i = imagpart(*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))
return _num1();
if (::instanceof(r, cl_I_ring) && ::instanceof(i, cl_RA_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))
- return numeric(lcm(::denominator(The(cl_RA)(r)), ::denominator(The(cl_RA)(i))));
+ return numeric(::lcm(::denominator(The(cl_RA)(r)), ::denominator(The(cl_RA)(i))));
}
#else
if (instanceof(*value, cl_RA_ring)) {
return numeric(TheRatio(*value)->denominator);
}
- if (!is_real()) { // complex case, handle Q(i):
- cl_R r = realpart(*value);
- cl_R i = imagpart(*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))
return _num1();
if (instanceof(r, cl_I_ring) && instanceof(i, cl_RA_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))
- return numeric(lcm(TheRatio(r)->denominator, TheRatio(i)->denominator));
+ return numeric(::lcm(TheRatio(r)->denominator, TheRatio(i)->denominator));
}
#endif // def SANE_LINKER
// at least one float encountered
* in two's complement if it is an integer, 0 otherwise. */
int numeric::int_length(void) const
{
- if (is_integer())
+ if (this->is_integer())
return ::integer_length(The(cl_I)(*value)); // -> CLN
else
return 0;
const type_info & typeid_numeric=typeid(some_numeric);
/** Imaginary unit. This is not a constant but a numeric since we are
* natively handing complex numbers anyways. */
-const numeric I = numeric(complex(cl_I(0),cl_I(1)));
+const numeric I = numeric(::complex(cl_I(0),cl_I(1)));
/** Exponential function.
const numeric atan(const numeric & y, const numeric & x)
{
if (x.is_real() && y.is_real())
- return ::atan(realpart(*x.value), realpart(*y.value)); // -> CLN
+ return ::atan(::realpart(*x.value), ::realpart(*y.value)); // -> CLN
else
throw (std::invalid_argument("numeric::atan(): complex argument"));
}
// being an exact zero for CLN, which can be tested and then we can just
// pass the number casted to an int:
if (x.is_real()) {
- int aux = (int)(::cl_double_approx(realpart(*x.value)));
+ int aux = (int)(::cl_double_approx(::realpart(*x.value)));
if (zerop(*x.value-aux))
return ::cl_zeta(aux); // -> CLN
}
* @return a mod b in the range [-iquo(abs(m)-1,2), iquo(abs(m),2)]. */
numeric smod(const numeric & a, const numeric & b)
{
- // FIXME: Should this become a member function?
if (a.is_integer() && b.is_integer()) {
cl_I b2 = The(cl_I)(ceiling1(The(cl_I)(*b.value) / 2)) - 1;
return ::mod(The(cl_I)(*a.value) + b2, The(cl_I)(*b.value)) - b2;
/** Floating point evaluation of Archimedes' constant Pi. */
ex PiEvalf(void)
{
- return numeric(cl_pi(cl_default_float_format)); // -> CLN
+ return numeric(::cl_pi(cl_default_float_format)); // -> CLN
}
/** Floating point evaluation of Euler's constant Gamma. */
ex EulerGammaEvalf(void)
{
- return numeric(cl_eulerconst(cl_default_float_format)); // -> CLN
+ return numeric(::cl_eulerconst(cl_default_float_format)); // -> CLN
}
/** Floating point evaluation of Catalan's constant. */
ex CatalanEvalf(void)
{
- return numeric(cl_catalanconst(cl_default_float_format)); // -> CLN
+ return numeric(::cl_catalanconst(cl_default_float_format)); // -> CLN
}
{
assert(!too_late);
too_late = true;
- cl_default_float_format = cl_float_format(17);
+ cl_default_float_format = ::cl_float_format(17);
}
_numeric_digits& _numeric_digits::operator=(long prec)
{
digits=prec;
- cl_default_float_format = cl_float_format(prec);
+ cl_default_float_format = ::cl_float_format(prec);
return *this;
}