X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Fex.cpp;h=c41abee74b5131ea157c9b0b27d842016caddd5c;hb=f82099178e27212fdc6801bc609202c0f9c2193e;hp=1849789871585a3d96318454d8f49e86769bae2c;hpb=9961dfdd7a383f09b1040e195a8817a85d945e58;p=ginac.git

diff --git a/ginac/ex.cpp b/ginac/ex.cpp
index 18497898..c41abee7 100644
--- a/ginac/ex.cpp
+++ b/ginac/ex.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's light-weight expression handles. */
 
 /*
- *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2002 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
@@ -32,7 +32,6 @@
 #include "lst.h"
 #include "relational.h"
 #include "input_lexer.h"
-#include "debugmsg.h"
 #include "utils.h"
 
 namespace GiNaC {
@@ -43,39 +42,12 @@ namespace GiNaC {
 
 // none (all inlined)
 
-//////////
-// functions overriding virtual functions from bases classes
-//////////
-
-// none
-
-//////////
-// new virtual functions which can be overridden by derived classes
-//////////
-
-// none
-
 //////////
 // non-virtual functions in this class
 //////////
 
 // public
-
-/** Efficiently swap the contents of two expressions. */
-void ex::swap(ex & other)
-{
-	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;
-}
-
 /** Print expression to stream. The formatting of the output is determined
  *  by the kind of print_context object that is passed. Possible formattings
  *  include ginsh-parsable output (the default), tree-like output for
@@ -83,7 +55,6 @@ void ex::swap(ex & other)
  *  @see print_context */
 void ex::print(const print_context & c, unsigned level) const
 {
-	debugmsg("ex print", LOGLEVEL_PRINT);
 	GINAC_ASSERT(bp!=0);
 	bp->print(c, level);
 }
@@ -91,7 +62,6 @@ void ex::print(const print_context & c, unsigned level) const
 /** Print expression to stream in a tree-like format suitable for debugging. */
 void ex::printtree(std::ostream & os) const
 {
-	debugmsg("ex printtree", LOGLEVEL_PRINT);
 	GINAC_ASSERT(bp!=0);
 	bp->print(print_tree(os));
 }
@@ -99,7 +69,6 @@ void ex::printtree(std::ostream & os) const
 /** 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();
 }
@@ -107,7 +76,6 @@ void ex::dbgprint(void) const
 /** 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();
 }
@@ -115,7 +83,7 @@ void ex::dbgprinttree(void) const
 ex ex::expand(unsigned options) const
 {
 	GINAC_ASSERT(bp!=0);
-	if (bp->flags & status_flags::expanded)
+	if (options == 0 && (bp->flags & status_flags::expanded)) // The "expanded" flag only covers the standard options; someone might want to re-expand with different options
 		return *bp;
 	else
 		return bp->expand(options);
@@ -143,16 +111,33 @@ bool ex::match(const ex & pattern) const
 	return bp->match(pattern, repl_lst);
 }
 
+/** Find all occurrences of a pattern. The found matches are appended to
+ *  the "found" list. If the expression itself matches the pattern, the
+ *  children are not further examined. This function returns true when any
+ *  matches were found. */
+bool ex::find(const ex & pattern, lst & found) const
+{
+	if (match(pattern)) {
+		found.append(*this);
+		found.sort();
+		found.unique();
+		return true;
+	}
+	bool any_found = false;
+	for (unsigned i=0; i<nops(); i++)
+		if (op(i).find(pattern, found))
+			any_found = true;
+	return any_found;
+}
+
 ex ex::operator[](const ex & index) const
 {
-	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];
 }
@@ -160,7 +145,6 @@ ex ex::operator[](int i) const
 /** 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);
@@ -169,7 +153,6 @@ ex & ex::let_op(int i)
 /** Left hand side of relational expression. */
 ex ex::lhs(void) const
 {
-	debugmsg("ex lhs()",LOGLEVEL_MEMBER_FUNCTION);
 	if (!is_ex_of_type(*this,relational))
 		throw std::runtime_error("ex::lhs(): not a relation");
 	return (*static_cast<relational *>(bp)).lhs();
@@ -178,7 +161,6 @@ ex ex::lhs(void) const
 /** Right hand side of relational expression. */
 ex ex::rhs(void) const
 {
-	debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION);
 	if (!is_ex_of_type(*this,relational))
 		throw std::runtime_error("ex::rhs(): not a relation");
 	return (*static_cast<relational *>(bp)).rhs();
@@ -190,7 +172,6 @@ ex ex::rhs(void) const
  *  unlinking the object and creating an unshared copy of it. */
 void ex::makewriteable()
 {
-	debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION);
 	GINAC_ASSERT(bp!=0);
 	GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 	if (bp->refcount > 1) {
@@ -207,14 +188,12 @@ void ex::makewriteable()
  *  @see ex::ex(const basic &) */
 void ex::construct_from_basic(const basic & other)
 {
-	if ((other.flags & status_flags::evaluated)==0) {
-		// cf. copy ctor
+	if (!(other.flags & status_flags::evaluated)) {
 		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))
+		if ((other.refcount==0) && (other.flags & status_flags::dynallocated))
 			delete &const_cast<basic &>(other);
 	} else {
 		if (other.flags & status_flags::dynallocated) {
@@ -234,25 +213,105 @@ void ex::construct_from_basic(const basic & other)
 
 void ex::construct_from_int(int i)
 {
-	switch (i) {  // some tiny efficiency-hack
+	switch (i) {  // prefer flyweights over new objects
+	case -12:
+		bp = (basic*)_num_12_p;
+		++bp->refcount;
+		break;
+	case -11:
+		bp = (basic*)_num_11_p;
+		++bp->refcount;
+		break;
+	case -10:
+		bp = (basic*)_num_10_p;
+		++bp->refcount;
+		break;
+	case -9:
+		bp = (basic*)_num_9_p;
+		++bp->refcount;
+		break;
+	case -8:
+		bp = (basic*)_num_8_p;
+		++bp->refcount;
+		break;
+	case -7:
+		bp = (basic*)_num_7_p;
+		++bp->refcount;
+		break;
+	case -6:
+		bp = (basic*)_num_6_p;
+		++bp->refcount;
+		break;
+	case -5:
+		bp = (basic*)_num_5_p;
+		++bp->refcount;
+		break;
+	case -4:
+		bp = (basic*)_num_4_p;
+		++bp->refcount;
+		break;
+	case -3:
+		bp = (basic*)_num_3_p;
+		++bp->refcount;
+		break;
 	case -2:
-		bp = _ex_2().bp;
+		bp = (basic*)_num_2_p;
 		++bp->refcount;
 		break;
 	case -1:
-		bp = _ex_1().bp;
+		bp = (basic*)_num_1_p;
 		++bp->refcount;
 		break;
 	case 0:
-		bp = _ex0().bp;
+		bp = (basic*)_num0_p;
 		++bp->refcount;
 		break;
 	case 1:
-		bp = _ex1().bp;
+		bp = (basic*)_num1_p;
 		++bp->refcount;
 		break;
 	case 2:
-		bp = _ex2().bp;
+		bp = (basic*)_num2_p;
+		++bp->refcount;
+		break;
+	case 3:
+		bp = (basic*)_num3_p;
+		++bp->refcount;
+		break;
+	case 4:
+		bp = (basic*)_num4_p;
+		++bp->refcount;
+		break;
+	case 5:
+		bp = (basic*)_num5_p;
+		++bp->refcount;
+		break;
+	case 6:
+		bp = (basic*)_num6_p;
+		++bp->refcount;
+		break;
+	case 7:
+		bp = (basic*)_num7_p;
+		++bp->refcount;
+		break;
+	case 8:
+		bp = (basic*)_num8_p;
+		++bp->refcount;
+		break;
+	case 9:
+		bp = (basic*)_num9_p;
+		++bp->refcount;
+		break;
+	case 10:
+		bp = (basic*)_num10_p;
+		++bp->refcount;
+		break;
+	case 11:
+		bp = (basic*)_num11_p;
+		++bp->refcount;
+		break;
+	case 12:
+		bp = (basic*)_num12_p;
 		++bp->refcount;
 		break;
 	default:
@@ -266,17 +325,57 @@ void ex::construct_from_int(int i)
 	
 void ex::construct_from_uint(unsigned int i)
 {
-	switch (i) {  // some tiny efficiency-hack
+	switch (i) {  // prefer flyweights over new objects
 	case 0:
-		bp = _ex0().bp;
+		bp = (basic*)_num0_p;
 		++bp->refcount;
 		break;
 	case 1:
-		bp = _ex1().bp;
+		bp = (basic*)_num1_p;
 		++bp->refcount;
 		break;
 	case 2:
-		bp = _ex2().bp;
+		bp = (basic*)_num2_p;
+		++bp->refcount;
+		break;
+	case 3:
+		bp = (basic*)_num3_p;
+		++bp->refcount;
+		break;
+	case 4:
+		bp = (basic*)_num4_p;
+		++bp->refcount;
+		break;
+	case 5:
+		bp = (basic*)_num5_p;
+		++bp->refcount;
+		break;
+	case 6:
+		bp = (basic*)_num6_p;
+		++bp->refcount;
+		break;
+	case 7:
+		bp = (basic*)_num7_p;
+		++bp->refcount;
+		break;
+	case 8:
+		bp = (basic*)_num8_p;
+		++bp->refcount;
+		break;
+	case 9:
+		bp = (basic*)_num9_p;
+		++bp->refcount;
+		break;
+	case 10:
+		bp = (basic*)_num10_p;
+		++bp->refcount;
+		break;
+	case 11:
+		bp = (basic*)_num11_p;
+		++bp->refcount;
+		break;
+	case 12:
+		bp = (basic*)_num12_p;
 		++bp->refcount;
 		break;
 	default:
@@ -290,25 +389,105 @@ void ex::construct_from_uint(unsigned int i)
 	
 void ex::construct_from_long(long i)
 {
-	switch (i) {  // some tiny efficiency-hack
+	switch (i) {  // prefer flyweights over new objects
+	case -12:
+		bp = (basic*)_num_12_p;
+		++bp->refcount;
+		break;
+	case -11:
+		bp = (basic*)_num_11_p;
+		++bp->refcount;
+		break;
+	case -10:
+		bp = (basic*)_num_10_p;
+		++bp->refcount;
+		break;
+	case -9:
+		bp = (basic*)_num_9_p;
+		++bp->refcount;
+		break;
+	case -8:
+		bp = (basic*)_num_8_p;
+		++bp->refcount;
+		break;
+	case -7:
+		bp = (basic*)_num_7_p;
+		++bp->refcount;
+		break;
+	case -6:
+		bp = (basic*)_num_6_p;
+		++bp->refcount;
+		break;
+	case -5:
+		bp = (basic*)_num_5_p;
+		++bp->refcount;
+		break;
+	case -4:
+		bp = (basic*)_num_4_p;
+		++bp->refcount;
+		break;
+	case -3:
+		bp = (basic*)_num_3_p;
+		++bp->refcount;
+		break;
 	case -2:
-		bp = _ex_2().bp;
+		bp = (basic*)_num_2_p;
 		++bp->refcount;
 		break;
 	case -1:
-		bp = _ex_1().bp;
+		bp = (basic*)_num_1_p;
 		++bp->refcount;
 		break;
 	case 0:
-		bp = _ex0().bp;
+		bp = (basic*)_num0_p;
 		++bp->refcount;
 		break;
 	case 1:
-		bp = _ex1().bp;
+		bp = (basic*)_num1_p;
 		++bp->refcount;
 		break;
 	case 2:
-		bp = _ex2().bp;
+		bp = (basic*)_num2_p;
+		++bp->refcount;
+		break;
+	case 3:
+		bp = (basic*)_num3_p;
+		++bp->refcount;
+		break;
+	case 4:
+		bp = (basic*)_num4_p;
+		++bp->refcount;
+		break;
+	case 5:
+		bp = (basic*)_num5_p;
+		++bp->refcount;
+		break;
+	case 6:
+		bp = (basic*)_num6_p;
+		++bp->refcount;
+		break;
+	case 7:
+		bp = (basic*)_num7_p;
+		++bp->refcount;
+		break;
+	case 8:
+		bp = (basic*)_num8_p;
+		++bp->refcount;
+		break;
+	case 9:
+		bp = (basic*)_num9_p;
+		++bp->refcount;
+		break;
+	case 10:
+		bp = (basic*)_num10_p;
+		++bp->refcount;
+		break;
+	case 11:
+		bp = (basic*)_num11_p;
+		++bp->refcount;
+		break;
+	case 12:
+		bp = (basic*)_num12_p;
 		++bp->refcount;
 		break;
 	default:
@@ -322,17 +501,57 @@ void ex::construct_from_long(long i)
 	
 void ex::construct_from_ulong(unsigned long i)
 {
-	switch (i) {  // some tiny efficiency-hack
+	switch (i) {  // prefer flyweights over new objects
 	case 0:
-		bp = _ex0().bp;
+		bp = (basic*)_num0_p;
 		++bp->refcount;
 		break;
 	case 1:
-		bp = _ex1().bp;
+		bp = (basic*)_num1_p;
 		++bp->refcount;
 		break;
 	case 2:
-		bp = _ex2().bp;
+		bp = (basic*)_num2_p;
+		++bp->refcount;
+		break;
+	case 3:
+		bp = (basic*)_num3_p;
+		++bp->refcount;
+		break;
+	case 4:
+		bp = (basic*)_num4_p;
+		++bp->refcount;
+		break;
+	case 5:
+		bp = (basic*)_num5_p;
+		++bp->refcount;
+		break;
+	case 6:
+		bp = (basic*)_num6_p;
+		++bp->refcount;
+		break;
+	case 7:
+		bp = (basic*)_num7_p;
+		++bp->refcount;
+		break;
+	case 8:
+		bp = (basic*)_num8_p;
+		++bp->refcount;
+		break;
+	case 9:
+		bp = (basic*)_num9_p;
+		++bp->refcount;
+		break;
+	case 10:
+		bp = (basic*)_num10_p;
+		++bp->refcount;
+		break;
+	case 11:
+		bp = (basic*)_num11_p;
+		++bp->refcount;
+		break;
+	case 12:
+		bp = (basic*)_num12_p;
 		++bp->refcount;
 		break;
 	default: