X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=5414cd5a8dc195944fb96b6d3fc0d81dac8e2179;hp=5c6853a766bb8e9b27bf59b08b3215e0f627b011;hb=6d89c8f370b4f5f98319f340aa0da31cbdff0dc5;hpb=3005c6200feea765472fb721393b1185e92b79c9

diff --git a/ginac/ex.cpp b/ginac/ex.cpp
index 5c6853a7..5414cd5a 100644
--- a/ginac/ex.cpp
+++ b/ginac/ex.cpp
@@ -48,45 +48,44 @@ namespace GiNaC {
 
 ex::ex() : bp(_ex0().bp)
 {
-    debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT);
-    GINAC_ASSERT(_ex0().bp!=0);
-    GINAC_ASSERT(_ex0().bp->flags & status_flags::dynallocated);
-    GINAC_ASSERT(bp!=0);
-    ++bp->refcount;
+	debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT);
+	GINAC_ASSERT(_ex0().bp!=0);
+	GINAC_ASSERT(_ex0().bp->flags & status_flags::dynallocated);
+	GINAC_ASSERT(bp!=0);
+	++bp->refcount;
 }
 
 ex::~ex()
 {
-    debugmsg("ex destructor",LOGLEVEL_DESTRUCT);
-    GINAC_ASSERT(bp!=0);
-    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
-    if (--bp->refcount == 0) {
-        delete bp;
-    }
+	debugmsg("ex destructor",LOGLEVEL_DESTRUCT);
+	GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+	if (--bp->refcount == 0) {
+		delete bp;
+	}
 }
 
 ex::ex(const ex & other) : bp(other.bp)
 {
-    debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT);
-    GINAC_ASSERT(bp!=0);
-    GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
-    ++bp->refcount;
+	debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT);
+	GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+	++bp->refcount;
 }
 
 const ex & ex::operator=(const ex & other)
 {
-    debugmsg("ex operator=",LOGLEVEL_ASSIGNMENT);
-    GINAC_ASSERT(bp!=0);
-    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
-    GINAC_ASSERT(other.bp!=0);
-    GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
-    ++other.bp->refcount;
-    basic * tmpbp=other.bp;
-    if (--bp->refcount==0) {
-            delete bp;
-    }
-    bp=tmpbp;
-    return *this;
+	debugmsg("ex operator=",LOGLEVEL_ASSIGNMENT);
+	GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+	GINAC_ASSERT(other.bp!=0);
+	GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
+	++other.bp->refcount;
+	basic * tmpbp = other.bp;
+	if (--bp->refcount==0)
+		delete bp;
+	bp = tmpbp;
+	return *this;
 }
 
 #endif // ndef INLINE_EX_CONSTRUCTORS
@@ -101,44 +100,44 @@ const ex & ex::operator=(const ex & other)
 
 ex::ex(const basic & other)
 {
-    debugmsg("ex constructor from basic",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(other);
+	debugmsg("ex constructor from basic",LOGLEVEL_CONSTRUCT);
+	construct_from_basic(other);
 }
 
 ex::ex(int i)
 {
-    debugmsg("ex constructor from int",LOGLEVEL_CONSTRUCT);
-    construct_from_int(i);
+	debugmsg("ex constructor from int",LOGLEVEL_CONSTRUCT);
+	construct_from_int(i);
 }
 
 ex::ex(unsigned int i)
 {
-    debugmsg("ex constructor from unsigned int",LOGLEVEL_CONSTRUCT);
-    construct_from_uint(i);
+	debugmsg("ex constructor from unsigned int",LOGLEVEL_CONSTRUCT);
+	construct_from_uint(i);
 }
 
 ex::ex(long i)
 {
-    debugmsg("ex constructor from long",LOGLEVEL_CONSTRUCT);
-    construct_from_long(i);
+	debugmsg("ex constructor from long",LOGLEVEL_CONSTRUCT);
+	construct_from_long(i);
 }
 
 ex::ex(unsigned long i)
 {
-    debugmsg("ex constructor from unsigned long",LOGLEVEL_CONSTRUCT);
-    construct_from_ulong(i);
+	debugmsg("ex constructor from unsigned long",LOGLEVEL_CONSTRUCT);
+	construct_from_ulong(i);
 }
 
 ex::ex(double const d)
 {
-    debugmsg("ex constructor from double",LOGLEVEL_CONSTRUCT);
-    construct_from_double(d);
+	debugmsg("ex constructor from double",LOGLEVEL_CONSTRUCT);
+	construct_from_double(d);
 }
 
-ex::ex(const string &s, const ex &l)
+ex::ex(const std::string &s, const ex &l)
 {
-    debugmsg("ex constructor from string,lst",LOGLEVEL_CONSTRUCT);
-    construct_from_string_and_lst(s, l);
+	debugmsg("ex constructor from string,lst",LOGLEVEL_CONSTRUCT);
+	construct_from_string_and_lst(s, l);
 }
 
 #endif // ndef INLINE_EX_CONSTRUCTORS
@@ -164,41 +163,41 @@ ex::ex(const string &s, const ex &l)
 /** Swap the contents of two expressions. */
 void ex::swap(ex & other)
 {
-    debugmsg("ex swap",LOGLEVEL_MEMBER_FUNCTION);
+	debugmsg("ex swap",LOGLEVEL_MEMBER_FUNCTION);
 
-    GINAC_ASSERT(bp!=0);
-    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
-    GINAC_ASSERT(other.bp!=0);
-    GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
-    
-    basic * tmpbp=bp;
-    bp=other.bp;
-    other.bp=tmpbp;
+	GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+	GINAC_ASSERT(other.bp!=0);
+	GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
+	
+	basic * tmpbp=bp;
+	bp=other.bp;
+	other.bp=tmpbp;
 }
 
 /** Output formatted to be useful as ginsh input. */
-void ex::print(ostream & os, unsigned upper_precedence) const
+void ex::print(std::ostream & os, unsigned upper_precedence) const
 {
-    debugmsg("ex print",LOGLEVEL_PRINT);
-    GINAC_ASSERT(bp!=0);
-    bp->print(os,upper_precedence);
+	debugmsg("ex print",LOGLEVEL_PRINT);
+	GINAC_ASSERT(bp!=0);
+	bp->print(os,upper_precedence);
 }
 
-void ex::printraw(ostream & os) const
+void ex::printraw(std::ostream & os) const
 {
-    debugmsg("ex printraw",LOGLEVEL_PRINT);
-    GINAC_ASSERT(bp!=0);
-    os << "ex(";
-    bp->printraw(os);
-    os << ")";
+	debugmsg("ex printraw",LOGLEVEL_PRINT);
+	GINAC_ASSERT(bp!=0);
+	os << "ex(";
+	bp->printraw(os);
+	os << ")";
 }
 
-void ex::printtree(ostream & os, unsigned indent) const
+void ex::printtree(std::ostream & os, unsigned indent) const
 {
-    debugmsg("ex printtree",LOGLEVEL_PRINT);
-    GINAC_ASSERT(bp!=0);
-    // os << "refcount=" << bp->refcount << " ";
-    bp->printtree(os,indent);
+	debugmsg("ex printtree",LOGLEVEL_PRINT);
+	GINAC_ASSERT(bp!=0);
+	// os << "refcount=" << bp->refcount << " ";
+	bp->printtree(os,indent);
 }
 
 /** Print expression as a C++ statement. The output looks like
@@ -208,102 +207,102 @@ void ex::printtree(ostream & os, unsigned indent) const
  *  @param os output stream
  *  @param type variable type (one of the csrc_types)
  *  @param var_name variable name to be printed */
-void ex::printcsrc(ostream & os, unsigned type, const char *var_name) const
-{
-    debugmsg("ex print csrc", LOGLEVEL_PRINT);
-    GINAC_ASSERT(bp!=0);
-    switch (type) {
-        case csrc_types::ctype_float:
-            os << "float ";
-            break;
-        case csrc_types::ctype_double:
-            os << "double ";
-            break;
-        case csrc_types::ctype_cl_N:
-            os << "cl_N ";
-            break;
-    }
-    os << var_name << " = ";
-    bp->printcsrc(os, type, 0);
-    os << ";\n";
+void ex::printcsrc(std::ostream & os, unsigned type, const char *var_name) const
+{
+	debugmsg("ex print csrc", LOGLEVEL_PRINT);
+	GINAC_ASSERT(bp!=0);
+	switch (type) {
+		case csrc_types::ctype_float:
+			os << "float ";
+			break;
+		case csrc_types::ctype_double:
+			os << "double ";
+			break;
+		case csrc_types::ctype_cl_N:
+			os << "cl_N ";
+			break;
+	}
+	os << var_name << " = ";
+	bp->printcsrc(os, type, 0);
+	os << ";\n";
 }
 
 /** Little wrapper arount print to be called within a debugger. */
 void ex::dbgprint(void) const
 {
-    debugmsg("ex dbgprint",LOGLEVEL_PRINT);
-    GINAC_ASSERT(bp!=0);
-    bp->dbgprint();
+	debugmsg("ex dbgprint",LOGLEVEL_PRINT);
+	GINAC_ASSERT(bp!=0);
+	bp->dbgprint();
 }
 
 /** Little wrapper arount printtree to be called within a debugger. */
 void ex::dbgprinttree(void) const
 {
-    debugmsg("ex dbgprinttree",LOGLEVEL_PRINT);
-    GINAC_ASSERT(bp!=0);
-    bp->dbgprinttree();
+	debugmsg("ex dbgprinttree",LOGLEVEL_PRINT);
+	GINAC_ASSERT(bp!=0);
+	bp->dbgprinttree();
 }
 
 bool ex::info(unsigned inf) const
 {
-    return bp->info(inf);
+	return bp->info(inf);
 }
 
 unsigned ex::nops() const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->nops();
+	GINAC_ASSERT(bp!=0);
+	return bp->nops();
 }
 
 ex ex::expand(unsigned options) const
 {
-    GINAC_ASSERT(bp!=0);
-    if (bp->flags & status_flags::expanded)
-        return *bp;
-    else
-        return bp->expand(options);
+	GINAC_ASSERT(bp!=0);
+	if (bp->flags & status_flags::expanded)
+		return *bp;
+	else
+		return bp->expand(options);
 }
 
 bool ex::has(const ex & other) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->has(other);
+	GINAC_ASSERT(bp!=0);
+	return bp->has(other);
 }
 
 int ex::degree(const symbol & s) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->degree(s);
+	GINAC_ASSERT(bp!=0);
+	return bp->degree(s);
 }
 
 int ex::ldegree(const symbol & s) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->ldegree(s);
+	GINAC_ASSERT(bp!=0);
+	return bp->ldegree(s);
 }
 
 ex ex::coeff(const symbol & s, int n) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->coeff(s,n);
+	GINAC_ASSERT(bp!=0);
+	return bp->coeff(s,n);
 }
 
 ex ex::collect(const symbol & s) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->collect(s);
+	GINAC_ASSERT(bp!=0);
+	return bp->collect(s);
 }
 
 ex ex::eval(int level) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->eval(level);
+	GINAC_ASSERT(bp!=0);
+	return bp->eval(level);
 }
 
 ex ex::evalf(int level) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->evalf(level);
+	GINAC_ASSERT(bp!=0);
+	return bp->evalf(level);
 }
 
 /** Compute partial derivative of an expression.
@@ -313,340 +312,326 @@ ex ex::evalf(int level) const
  *  @return partial derivative as a new expression */
 ex ex::diff(const symbol & s, unsigned nth) const
 {
-    GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT(bp!=0);
 
-    if (!nth)
-        return *this;
-    else
-        return bp->diff(s, nth);
+	if (!nth)
+		return *this;
+	else
+		return bp->diff(s, nth);
 }
 
 ex ex::subs(const lst & ls, const lst & lr) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->subs(ls,lr);
+	GINAC_ASSERT(bp!=0);
+	return bp->subs(ls,lr);
 }
 
 ex ex::subs(const ex & e) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->subs(e);
+	GINAC_ASSERT(bp!=0);
+	return bp->subs(e);
 }
 
 exvector ex::get_indices(void) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->get_indices();
+	GINAC_ASSERT(bp!=0);
+	return bp->get_indices();
 }
 
 ex ex::simplify_ncmul(const exvector & v) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->simplify_ncmul(v);
+	GINAC_ASSERT(bp!=0);
+	return bp->simplify_ncmul(v);
 }
 
 ex ex::operator[](const ex & index) const
 {
-    debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
-    GINAC_ASSERT(bp!=0);
-    return (*bp)[index];
+	debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
+	GINAC_ASSERT(bp!=0);
+	return (*bp)[index];
 }
 
 ex ex::operator[](int i) const
 {
-    debugmsg("ex operator[int]",LOGLEVEL_OPERATOR);
-    GINAC_ASSERT(bp!=0);
-    return (*bp)[i];
+	debugmsg("ex operator[int]",LOGLEVEL_OPERATOR);
+	GINAC_ASSERT(bp!=0);
+	return (*bp)[i];
 }
 
 /** Return operand/member at position i. */
 ex ex::op(int i) const
 {
-    debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION);
-    GINAC_ASSERT(bp!=0);
-    return bp->op(i);
+	debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION);
+	GINAC_ASSERT(bp!=0);
+	return bp->op(i);
 }
 
 /** Return modifyable operand/member at position i. */
 ex & ex::let_op(int i)
 {
-    debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION);
-    makewriteable();
-    GINAC_ASSERT(bp!=0);
-    return bp->let_op(i);
+	debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION);
+	makewriteable();
+	GINAC_ASSERT(bp!=0);
+	return bp->let_op(i);
 }
 
 /** Left hand side of relational expression. */
 ex ex::lhs(void) const
 {
-    debugmsg("ex lhs()",LOGLEVEL_MEMBER_FUNCTION);
-    GINAC_ASSERT(is_ex_of_type(*this,relational));
-    return (*static_cast<relational *>(bp)).lhs();
+	debugmsg("ex lhs()",LOGLEVEL_MEMBER_FUNCTION);
+	GINAC_ASSERT(is_ex_of_type(*this,relational));
+	return (*static_cast<relational *>(bp)).lhs();
 }
 
 /** Right hand side of relational expression. */
 ex ex::rhs(void) const
 {
-    debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION);
-    GINAC_ASSERT(is_ex_of_type(*this,relational));
-    return (*static_cast<relational *>(bp)).rhs();
+	debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION);
+	GINAC_ASSERT(is_ex_of_type(*this,relational));
+	return (*static_cast<relational *>(bp)).rhs();
 }
 
 #ifndef INLINE_EX_CONSTRUCTORS
 int ex::compare(const ex & other) const
 {
-    GINAC_ASSERT(bp!=0);
-    GINAC_ASSERT(other.bp!=0);
-    if (bp==other.bp) {
-        // special case: both expression point to same basic, trivially equal
-        return 0; 
-    }
-    return bp->compare(*other.bp);
+	GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT(other.bp!=0);
+	if (bp==other.bp) {
+		// special case: both expression point to same basic, trivially equal
+		return 0; 
+	}
+	return bp->compare(*other.bp);
 }
 #endif // ndef INLINE_EX_CONSTRUCTORS
 
 #ifndef INLINE_EX_CONSTRUCTORS
 bool ex::is_equal(const ex & other) const
 {
-    GINAC_ASSERT(bp!=0);
-    GINAC_ASSERT(other.bp!=0);
-    if (bp==other.bp) {
-        // special case: both expression point to same basic, trivially equal
-        return true; 
-    }
-    return bp->is_equal(*other.bp);
+	GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT(other.bp!=0);
+	// if both expression point to same basic they are trivially equal
+	if (bp==other.bp)
+		return true;
+	
+	return bp->is_equal(*other.bp);
 }
 #endif // ndef INLINE_EX_CONSTRUCTORS
 
 unsigned ex::return_type(void) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->return_type();
+	GINAC_ASSERT(bp!=0);
+	return bp->return_type();
 }
 
 unsigned ex::return_type_tinfo(void) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->return_type_tinfo();
+	GINAC_ASSERT(bp!=0);
+	return bp->return_type_tinfo();
 }
 
 unsigned ex::gethash(void) const
 {
-    GINAC_ASSERT(bp!=0);
-    return bp->gethash();
+	GINAC_ASSERT(bp!=0);
+	return bp->gethash();
 }
 
 ex ex::exadd(const ex & rh) const
 {
-    return (new add(*this,rh))->setflag(status_flags::dynallocated);
+	return (new add(*this,rh))->setflag(status_flags::dynallocated);
 }
 
 ex ex::exmul(const ex & rh) const
 {
-    return (new mul(*this,rh))->setflag(status_flags::dynallocated);
+	return (new mul(*this,rh))->setflag(status_flags::dynallocated);
 }
 
 ex ex::exncmul(const ex & rh) const
 {
-    return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
+	return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
 }
 
 // private
 
 void ex::makewriteable()
 {
-    debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION);
-    GINAC_ASSERT(bp!=0);
-    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
-    if (bp->refcount > 1) {
-        basic * bp2 = bp->duplicate();
-        ++bp2->refcount;
-        bp2->setflag(status_flags::dynallocated);
-        --bp->refcount;
-        bp = bp2;
-    }
-    GINAC_ASSERT(bp->refcount == 1);
+	debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION);
+	GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+	if (bp->refcount > 1) {
+		basic * bp2 = bp->duplicate();
+		++bp2->refcount;
+		bp2->setflag(status_flags::dynallocated);
+		--bp->refcount;
+		bp = bp2;
+	}
+	GINAC_ASSERT(bp->refcount==1);
 }
 
 void ex::construct_from_basic(const basic & other)
 {
-    if ((other.flags & status_flags::evaluated)==0) {
-        // cf. copy constructor
-        const ex & tmpex = other.eval(1); // evaluate only one (top) level
-        bp = tmpex.bp;
-        GINAC_ASSERT(bp!=0);
-        GINAC_ASSERT(bp->flags & status_flags::dynallocated);
-        ++bp->refcount;
-        if ((other.flags & status_flags::dynallocated)&&(other.refcount==0)) {
-            delete &const_cast<basic &>(other);
-        }
-    } else {
-        if (other.flags & status_flags::dynallocated) {
-            bp = &const_cast<basic &>(other);
-        } else {
-            bp = other.duplicate();
-            bp->setflag(status_flags::dynallocated);
-        }
-        GINAC_ASSERT(bp!=0);
-        // bp->clearflag(status_flags::evaluated);
-        ++bp->refcount;
-    }
-    GINAC_ASSERT(bp!=0);
-    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+	if ((other.flags & status_flags::evaluated)==0) {
+		// cf. copy constructor
+		const ex & tmpex = other.eval(1); // evaluate only one (top) level
+		bp = tmpex.bp;
+		GINAC_ASSERT(bp!=0);
+		GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+		++bp->refcount;
+		if ((other.flags & status_flags::dynallocated)&&(other.refcount==0)) {
+			delete &const_cast<basic &>(other);
+		}
+	} else {
+		if (other.flags & status_flags::dynallocated) {
+			// it's on the heap, so just copy bp:
+			bp = &const_cast<basic &>(other);
+		} else {
+			// create a duplicate on the heap:
+			bp = other.duplicate();
+			bp->setflag(status_flags::dynallocated);
+		}
+		GINAC_ASSERT(bp!=0);
+		// bp->clearflag(status_flags::evaluated);
+		++bp->refcount;
+	}
+	GINAC_ASSERT(bp!=0);
+	GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 }
 
 void ex::construct_from_int(int i)
 {
-    switch (i) {  // some tiny efficiency-hack
-    case -2:
-        bp = _ex_2().bp;
-        ++bp->refcount;
-        break;
-    case -1:
-        bp = _ex_1().bp;
-        ++bp->refcount;
-        break;
-    case 0:
-        bp = _ex0().bp;
-        ++bp->refcount;
-        break;
-    case 1:
-        bp = _ex1().bp;
-        ++bp->refcount;
-        break;
-    case 2:
-        bp = _ex2().bp;
-        ++bp->refcount;
-        break;
-    default:
-        bp = new numeric(i);
-        bp->setflag(status_flags::dynallocated);
-        ++bp->refcount;
-        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
-        GINAC_ASSERT(bp->refcount=1);
-    }
-}
-    
+	switch (i) {  // some tiny efficiency-hack
+	case -2:
+		bp = _ex_2().bp;
+		++bp->refcount;
+		break;
+	case -1:
+		bp = _ex_1().bp;
+		++bp->refcount;
+		break;
+	case 0:
+		bp = _ex0().bp;
+		++bp->refcount;
+		break;
+	case 1:
+		bp = _ex1().bp;
+		++bp->refcount;
+		break;
+	case 2:
+		bp = _ex2().bp;
+		++bp->refcount;
+		break;
+	default:
+		bp = new numeric(i);
+		bp->setflag(status_flags::dynallocated);
+		++bp->refcount;
+		GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+		GINAC_ASSERT(bp->refcount==1);
+	}
+}
+	
 void ex::construct_from_uint(unsigned int i)
 {
-    switch (i) {  // some tiny efficiency-hack
-    case -2:
-        bp = _ex_2().bp;
-        ++bp->refcount;
-        break;
-    case -1:
-        bp = _ex_1().bp;
-        ++bp->refcount;
-        break;
-    case 0:
-        bp = _ex0().bp;
-        ++bp->refcount;
-        break;
-    case 1:
-        bp = _ex1().bp;
-        ++bp->refcount;
-        break;
-    case 2:
-        bp = _ex2().bp;
-        ++bp->refcount;
-        break;
-    default:
-        bp = new numeric(i);
-        bp->setflag(status_flags::dynallocated);
-        ++bp->refcount;
-        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
-        GINAC_ASSERT(bp->refcount=1);
-    }
-}
-    
+	switch (i) {  // some tiny efficiency-hack
+	case 0:
+		bp = _ex0().bp;
+		++bp->refcount;
+		break;
+	case 1:
+		bp = _ex1().bp;
+		++bp->refcount;
+		break;
+	case 2:
+		bp = _ex2().bp;
+		++bp->refcount;
+		break;
+	default:
+		bp = new numeric(i);
+		bp->setflag(status_flags::dynallocated);
+		++bp->refcount;
+		GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+		GINAC_ASSERT(bp->refcount==1);
+	}
+}
+	
 void ex::construct_from_long(long i)
 {
-    switch (i) {  // some tiny efficiency-hack
-    case -2:
-        bp = _ex_2().bp;
-        ++bp->refcount;
-        break;
-    case -1:
-        bp = _ex_1().bp;
-        ++bp->refcount;
-        break;
-    case 0:
-        bp = _ex0().bp;
-        ++bp->refcount;
-        break;
-    case 1:
-        bp = _ex1().bp;
-        ++bp->refcount;
-        break;
-    case 2:
-        bp = _ex2().bp;
-        ++bp->refcount;
-        break;
-    default:
-        bp = new numeric(i);
-        bp->setflag(status_flags::dynallocated);
-        ++bp->refcount;
-        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
-        GINAC_ASSERT(bp->refcount=1);
-    }
-}
-    
+	switch (i) {  // some tiny efficiency-hack
+	case -2:
+		bp = _ex_2().bp;
+		++bp->refcount;
+		break;
+	case -1:
+		bp = _ex_1().bp;
+		++bp->refcount;
+		break;
+	case 0:
+		bp = _ex0().bp;
+		++bp->refcount;
+		break;
+	case 1:
+		bp = _ex1().bp;
+		++bp->refcount;
+		break;
+	case 2:
+		bp = _ex2().bp;
+		++bp->refcount;
+		break;
+	default:
+		bp = new numeric(i);
+		bp->setflag(status_flags::dynallocated);
+		++bp->refcount;
+		GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+		GINAC_ASSERT(bp->refcount==1);
+	}
+}
+	
 void ex::construct_from_ulong(unsigned long i)
 {
-    switch (i) {  // some tiny efficiency-hack
-    case -2:
-        bp = _ex_2().bp;
-        ++bp->refcount;
-        break;
-    case -1:
-        bp = _ex_1().bp;
-        ++bp->refcount;
-        break;
-    case 0:
-        bp = _ex0().bp;
-        ++bp->refcount;
-        break;
-    case 1:
-        bp = _ex1().bp;
-        ++bp->refcount;
-        break;
-    case 2:
-        bp = _ex2().bp;
-        ++bp->refcount;
-        break;
-    default:
-        bp = new numeric(i);
-        bp->setflag(status_flags::dynallocated);
-        ++bp->refcount;
-        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
-        GINAC_ASSERT(bp->refcount=1);
-    }
-}
-    
+	switch (i) {  // some tiny efficiency-hack
+	case 0:
+		bp = _ex0().bp;
+		++bp->refcount;
+		break;
+	case 1:
+		bp = _ex1().bp;
+		++bp->refcount;
+		break;
+	case 2:
+		bp = _ex2().bp;
+		++bp->refcount;
+		break;
+	default:
+		bp = new numeric(i);
+		bp->setflag(status_flags::dynallocated);
+		++bp->refcount;
+		GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+		GINAC_ASSERT(bp->refcount==1);
+	}
+}
+	
 void ex::construct_from_double(double d)
 {
-    bp = new numeric(d);
-    bp->setflag(status_flags::dynallocated);
-    ++bp->refcount;
-    GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
-    GINAC_ASSERT(bp->refcount=1);
+	bp = new numeric(d);
+	bp->setflag(status_flags::dynallocated);
+	++bp->refcount;
+	GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+	GINAC_ASSERT(bp->refcount==1);
 }
 
-void ex::construct_from_string_and_lst(const string &s, const ex &l)
+void ex::construct_from_string_and_lst(const std::string &s, const ex &l)
 {
-    set_lexer_string(s);
-    set_lexer_symbols(l);
-    ginac_yyrestart(NULL);
-    if (ginac_yyparse())
-        throw (std::runtime_error(get_parser_error()));
-    else {
-        bp = parsed_ex.bp;
-        GINAC_ASSERT(bp!=0);
-        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
-        ++bp->refcount;
-    }
+	set_lexer_string(s);
+	set_lexer_symbols(l);
+	ginac_yyrestart(NULL);
+	if (ginac_yyparse())
+		throw (std::runtime_error(get_parser_error()));
+	else {
+		bp = parsed_ex.bp;
+		GINAC_ASSERT(bp!=0);
+		GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+		++bp->refcount;
+	}
 }
-    
+	
 //////////
 // static member variables
 //////////