]> www.ginac.de Git - ginac.git/blobdiff - ginac/basic.cpp
- Call `ginac-config --version` only once and safe the result.
[ginac.git] / ginac / basic.cpp
index 70f84ea83ef731336f16807973c3cd19f1315d07..2065eac8b6105424c679dd41c70dd145e49b8f6e 100644 (file)
@@ -34,6 +34,7 @@
 #include "lst.h"
 #include "ncmul.h"
 #include "relational.h"
+#include "wildcard.h"
 #include "print.h"
 #include "archive.h"
 #include "utils.h"
@@ -101,12 +102,6 @@ void basic::archive(archive_node &n) const
        n.add_string("class", class_name());
 }
 
-//////////
-// functions overriding virtual functions from bases classes
-//////////
-
-// none
-
 //////////
 // new virtual functions which can be overridden by derived classes
 //////////
@@ -202,9 +197,9 @@ ex & basic::let_op(int i)
 
 ex basic::operator[](const ex & index) const
 {
-       if (is_exactly_of_type(*index.bp,numeric))
-               return op(static_cast<const numeric &>(*index.bp).to_int());
-       
+       if (is_ex_exactly_of_type(index,numeric))
+               return op(ex_to<numeric>(index).to_int());
+
        throw(std::invalid_argument("non-numeric indices not supported by this type"));
 }
 
@@ -213,18 +208,17 @@ ex basic::operator[](int i) const
        return op(i);
 }
 
-/** Search ocurrences.  An object 'has' an expression if it is the expression
- *  itself or one of the children 'has' it.  As a consequence (according to
- *  the definition of children) given e=x+y+z, e.has(x) is true but e.has(x+y)
- *  is false.  The expression can also contain wildcards. */
-bool basic::has(const ex & other) const
+/** Test for occurrence of a pattern.  An object 'has' a pattern if it matches
+ *  the pattern itself or one of the children 'has' it.  As a consequence
+ *  (according to the definition of children) given e=x+y+z, e.has(x) is true
+ *  but e.has(x+y) is false. */
+bool basic::has(const ex & pattern) const
 {
-       GINAC_ASSERT(other.bp!=0);
        lst repl_lst;
-       if (match(*other.bp, repl_lst))
+       if (match(pattern, repl_lst))
                return true;
        for (unsigned i=0; i<nops(); i++)
-               if (op(i).has(other))
+               if (op(i).has(pattern))
                        return true;
        
        return false;
@@ -274,6 +268,8 @@ ex basic::collect(const ex & s, bool distributed) const
        if (is_ex_of_type(s, lst)) {
 
                // List of objects specified
+               if (s.nops() == 0)
+                       return *this;
                if (s.nops() == 1)
                        return collect(s.op(0));
 
@@ -309,7 +305,7 @@ ex basic::collect(const ex & s, bool distributed) const
                                // Increment counters
                                int n = num - 1;
                                while (true) {
-                                       si[n].cnt++;
+                                       ++si[n].cnt;
                                        if (si[n].cnt <= si[n].deg) {
                                                // Update coefficients
                                                ex c;
@@ -349,7 +345,7 @@ done:               delete[] si;
        return x + (*this - x).expand();
 }
 
-/** Perform automatic non-interruptive symbolic evaluation on expression. */
+/** Perform automatic non-interruptive term rewriting rules. */
 ex basic::eval(int level) const
 {
        // There is nothing to do for basic objects:
@@ -459,7 +455,7 @@ bool basic::match(const ex & pattern, lst & repl_lst) const
        But who is the king tonight?
        Who is the king tonight?
        Pattern is the thing, the key thing-a-ling,
-       But who is the king of pattern?
+       But who is the king of Pattern?
        But who is the king, the king thing-a-ling,
        Who is the king of Pattern?
        Bog is the king, the king thing-a-ling,
@@ -475,7 +471,7 @@ bool basic::match(const ex & pattern, lst & repl_lst) const
                // be the same expression)
                for (unsigned i=0; i<repl_lst.nops(); i++) {
                        if (repl_lst.op(i).op(0).is_equal(pattern))
-                               return is_equal(*repl_lst.op(i).op(1).bp);
+                               return is_equal(ex_to<basic>(repl_lst.op(i).op(1)));
                }
                repl_lst.append(pattern == *this);
                return true;
@@ -483,7 +479,7 @@ bool basic::match(const ex & pattern, lst & repl_lst) const
        } else {
 
                // Expression must be of the same type as the pattern
-               if (tinfo() != pattern.bp->tinfo())
+               if (tinfo() != ex_to<basic>(pattern).tinfo())
                        return false;
 
                // Number of subexpressions must match
@@ -493,7 +489,11 @@ bool basic::match(const ex & pattern, lst & repl_lst) const
                // No subexpressions? Then just compare the objects (there can't be
                // wildcards in the pattern)
                if (nops() == 0)
-                       return is_equal(*pattern.bp);
+                       return is_equal_same_type(ex_to<basic>(pattern));
+
+               // Check whether attributes that are not subexpressions match
+               if (!match_same_type(ex_to<basic>(pattern)))
+                       return false;
 
                // Otherwise the subexpressions must match one-to-one
                for (unsigned i=0; i<nops(); i++)
@@ -513,14 +513,14 @@ ex basic::subs(const lst & ls, const lst & lr, bool no_pattern) const
 
        if (no_pattern) {
                for (unsigned i=0; i<ls.nops(); i++) {
-                       if (is_equal(*ls.op(i).bp))
+                       if (is_equal(ex_to<basic>(ls.op(i))))
                                return lr.op(i);
                }
        } else {
                for (unsigned i=0; i<ls.nops(); i++) {
                        lst repl_lst;
-                       if (match(*ls.op(i).bp, repl_lst))
-                               return lr.op(i).bp->subs(repl_lst, true); // avoid infinite recursion when re-substituting the wildcards
+                       if (match(ex_to<basic>(ls.op(i)), repl_lst))
+                               return lr.op(i).subs(repl_lst, true); // avoid infinite recursion when re-substituting the wildcards
                }
        }
 
@@ -604,7 +604,24 @@ int basic::compare_same_type(const basic & other) const
  *  than an order relation and then it can be overridden. */
 bool basic::is_equal_same_type(const basic & other) const
 {
-       return this->compare_same_type(other)==0;
+       return compare_same_type(other)==0;
+}
+
+/** Returns true if the attributes of two objects are similar enough for
+ *  a match. This function must not match subexpressions (this is already
+ *  done by basic::match()). Only attributes not accessible by op() should
+ *  be compared. This is also the reason why this function doesn't take the
+ *  wildcard replacement list from match() as an argument: only subexpressions
+ *  are subject to wildcard matches. Also, this function only needs to be
+ *  implemented for container classes because is_equal_same_type() is
+ *  automatically used instead of match_same_type() if nops() == 0.
+ *
+ *  @see basic::match */
+bool basic::match_same_type(const basic & other) const
+{
+       // The default is to only consider subexpressions, but not any other
+       // attributes
+       return true;
 }
 
 unsigned basic::return_type(void) const
@@ -655,10 +672,10 @@ struct expand_map_function : public map_function {
 ex basic::expand(unsigned options) const
 {
        if (nops() == 0)
-               return this->setflag(status_flags::expanded);
+               return (options == 0) ? setflag(status_flags::expanded) : *this;
        else {
                expand_map_function map_expand(options);
-               return map(map_expand).bp->setflag(status_flags::expanded);
+               return ex_to<basic>(map(map_expand)).setflag(options == 0 ? status_flags::expanded : 0);
        }
 }
 
@@ -759,7 +776,7 @@ bool basic::is_equal(const basic & other) const
        
        GINAC_ASSERT(typeid(*this)==typeid(other));
        
-       return this->is_equal_same_type(other);
+       return is_equal_same_type(other);
 }
 
 // protected
@@ -769,7 +786,7 @@ bool basic::is_equal(const basic & other) const
  *  @see basic::eval */
 const basic & basic::hold(void) const
 {
-       return this->setflag(status_flags::evaluated);
+       return setflag(status_flags::evaluated);
 }
 
 /** Ensure the object may be modified without hurting others, throws if this