#include "ex.h"
#include "print.h"
#include "archive.h"
-#include "debugmsg.h"
#include "tostring.h"
#include "utils.h"
GINAC_IMPLEMENT_REGISTERED_CLASS(numeric, basic)
//////////
-// default ctor, dtor, copy ctor assignment
-// operator and helpers
+// default ctor, dtor, copy ctor, assignment operator and helpers
//////////
/** default ctor. Numerically it initializes to an integer zero. */
numeric::numeric() : basic(TINFO_numeric)
{
- debugmsg("numeric default ctor", LOGLEVEL_CONSTRUCT);
value = cln::cl_I(0);
setflag(status_flags::evaluated | status_flags::expanded);
}
numeric::numeric(int i) : basic(TINFO_numeric)
{
- debugmsg("numeric ctor 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
// emphasizes efficiency. However, if the integer is small enough,
numeric::numeric(unsigned int i) : basic(TINFO_numeric)
{
- debugmsg("numeric ctor 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
// emphasizes efficiency. However, if the integer is small enough,
numeric::numeric(long i) : basic(TINFO_numeric)
{
- debugmsg("numeric ctor from long",LOGLEVEL_CONSTRUCT);
value = cln::cl_I(i);
setflag(status_flags::evaluated | status_flags::expanded);
}
numeric::numeric(unsigned long i) : basic(TINFO_numeric)
{
- debugmsg("numeric ctor from ulong",LOGLEVEL_CONSTRUCT);
value = cln::cl_I(i);
setflag(status_flags::evaluated | status_flags::expanded);
}
* @exception overflow_error (division by zero) */
numeric::numeric(long numer, long denom) : basic(TINFO_numeric)
{
- debugmsg("numeric ctor from long/long",LOGLEVEL_CONSTRUCT);
if (!denom)
throw std::overflow_error("division by zero");
value = cln::cl_I(numer) / cln::cl_I(denom);
numeric::numeric(double d) : basic(TINFO_numeric)
{
- debugmsg("numeric ctor from double",LOGLEVEL_CONSTRUCT);
// We really want to explicitly use the type cl_LF instead of the
// more general cl_F, since that would give us a cl_DF only which
// will not be promoted to cl_LF if overflow occurs:
* notation like "2+5*I". */
numeric::numeric(const char *s) : basic(TINFO_numeric)
{
- debugmsg("numeric ctor from string",LOGLEVEL_CONSTRUCT);
cln::cl_N ctorval = 0;
// parse complex numbers (functional but not completely safe, unfortunately
// std::string does not understand regexpese):
// ss should represent a simple sum like 2+5*I
- std::string ss(s);
- // make it safe by adding explicit sign
+ std::string ss = s;
+ std::string::size_type delim;
+
+ // make this implementation safe by adding explicit sign
if (ss.at(0) != '+' && ss.at(0) != '-' && ss.at(0) != '#')
ss = '+' + ss;
- std::string::size_type delim;
+
+ // We use 'E' as exponent marker in the output, but some people insist on
+ // writing 'e' at input, so let's substitute them right at the beginning:
+ while ((delim = ss.find("e"))!=std::string::npos)
+ ss.replace(delim,1,"E");
+
+ // main parser loop:
do {
// chop ss into terms from left to right
std::string term;
bool imaginary = false;
delim = ss.find_first_of(std::string("+-"),1);
// Do we have an exponent marker like "31.415E-1"? If so, hop on!
- if ((delim != std::string::npos) && (ss.at(delim-1) == 'E'))
+ if (delim!=std::string::npos && ss.at(delim-1)=='E')
delim = ss.find_first_of(std::string("+-"),delim+1);
term = ss.substr(0,delim);
- if (delim != std::string::npos)
+ if (delim!=std::string::npos)
ss = ss.substr(delim);
// is the term imaginary?
- if (term.find("I") != std::string::npos) {
+ if (term.find("I")!=std::string::npos) {
// erase 'I':
- term = term.replace(term.find("I"),1,"");
+ term.erase(term.find("I"),1);
// erase '*':
- if (term.find("*") != std::string::npos)
- term = term.replace(term.find("*"),1,"");
+ if (term.find("*")!=std::string::npos)
+ term.erase(term.find("*"),1);
// correct for trivial +/-I without explicit factor on I:
- if (term.size() == 1)
- term += "1";
+ if (term.size()==1)
+ term += '1';
imaginary = true;
}
- if (term.find(".") != std::string::npos) {
+ if (term.find('.')!=std::string::npos || term.find('E')!=std::string::npos) {
// CLN's short type cl_SF is not very useful within the GiNaC
// framework where we are mainly interested in the arbitrary
// precision type cl_LF. Hence we go straight to the construction
// 31.4E-1 --> 31.4e-1_<Digits>
// and s on.
// No exponent marker? Let's add a trivial one.
- if (term.find("E") == std::string::npos)
+ if (term.find("E")==std::string::npos)
term += "E0";
// E to lower case
term = term.replace(term.find("E"),1,"e");
else
ctorval = ctorval + cln::cl_F(term.c_str());
} else {
- // not a floating point number...
+ // this is not a floating point number...
if (imaginary)
ctorval = ctorval + cln::complex(cln::cl_I(0),cln::cl_R(term.c_str()));
else
ctorval = ctorval + cln::cl_R(term.c_str());
}
- } while(delim != std::string::npos);
+ } while (delim != std::string::npos);
value = ctorval;
setflag(status_flags::evaluated | status_flags::expanded);
}
* only. */
numeric::numeric(const cln::cl_N &z) : basic(TINFO_numeric)
{
- debugmsg("numeric ctor from cl_N", LOGLEVEL_CONSTRUCT);
value = z;
setflag(status_flags::evaluated | status_flags::expanded);
}
numeric::numeric(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
{
- debugmsg("numeric ctor from archive_node", LOGLEVEL_CONSTRUCT);
cln::cl_N ctorval = 0;
// Read number as string
* @see print_real_number() */
void numeric::print(const print_context & c, unsigned level) const
{
- debugmsg("numeric print", LOGLEVEL_PRINT);
-
if (is_a<print_tree>(c)) {
c.s << std::string(level, ' ') << cln::the<cln::cl_N>(value)
const std::string mul_sym = is_a<print_latex>(c) ? " " : "*";
const cln::cl_R r = cln::realpart(cln::the<cln::cl_N>(value));
const cln::cl_R i = cln::imagpart(cln::the<cln::cl_N>(value));
+ if (is_a<print_python_repr>(c))
+ c.s << class_name() << "('";
if (cln::zerop(i)) {
// case 1, real: x or -x
if ((precedence() <= level) && (!this->is_nonneg_integer())) {
c.s << par_close;
}
}
+ if (is_a<print_python_repr>(c))
+ c.s << "')";
}
}
/** Append global Digits object to ostream. */
void _numeric_digits::print(std::ostream &os) const
{
- debugmsg("_numeric_digits print", LOGLEVEL_PRINT);
os << digits;
}
git://www.ginac.de / ginac.git / blobdiff