the old methods of ex remain for compatibility
authorChristian Bauer <Christian.Bauer@uni-mainz.de>
Thu, 4 Sep 2003 18:00:16 +0000 (18:00 +0000)
committerChristian Bauer <Christian.Bauer@uni-mainz.de>
Thu, 4 Sep 2003 18:00:16 +0000 (18:00 +0000)
ginac/basic.h
ginac/clifford.cpp
ginac/ex.h
ginac/expairseq.h
ginac/matrix.cpp
ginac/normal.cpp
ginac/numeric.h
ginac/power.h
ginac/structure.h
ginac/symbol.h

index e4c4b09b53daa61e4a4e7f481a989a4185a75d08..12a958c657ee317ebe32aa9706fd771f84066fad 100644 (file)
@@ -164,8 +164,8 @@ public:
 
        // rational functions
        virtual ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const;
-       virtual ex to_rational(lst &repl_lst) const;
-       virtual ex to_polynomial(lst &repl_lst) const;
+       virtual ex to_rational(exmap & repl) const;
+       virtual ex to_polynomial(exmap & repl) const;
 
        // polynomial algorithms
        virtual numeric integer_content() const;
index 717e444c41a5c39ac03deee33718447f25602ecc..7d4596d04682e3df479d5a97a8e5ce7f6d5eba2a 100644 (file)
@@ -706,13 +706,12 @@ ex dirac_trace(const ex & e, unsigned char rl, const ex & trONE)
 ex canonicalize_clifford(const ex & e)
 {
        // Scan for any ncmul objects
-       lst srl;
+       exmap srl;
        ex aux = e.to_rational(srl);
-       for (size_t i=0; i<srl.nops(); i++) {
+       for (exmap::iterator i = srl.begin(); i != srl.end(); ++i) {
 
-               ex o = srl.op(i);
-               ex lhs = o.lhs();
-               ex rhs = o.rhs();
+               ex lhs = i->first;
+               ex rhs = i->second;
 
                if (is_exactly_a<ncmul>(rhs)
                 && rhs.return_type() == return_types::noncommutative
@@ -721,7 +720,7 @@ ex canonicalize_clifford(const ex & e)
                        // Expand product, if necessary
                        ex rhs_expanded = rhs.expand();
                        if (!is_a<ncmul>(rhs_expanded)) {
-                               srl[i] = (lhs == canonicalize_clifford(rhs_expanded));
+                               i->second = canonicalize_clifford(rhs_expanded);
                                continue;
 
                        } else if (!is_a<clifford>(rhs.op(0)))
@@ -748,7 +747,7 @@ ex canonicalize_clifford(const ex & e)
                                        it[0] = save1;
                                        it[1] = save0;
                                        sum -= ncmul(v, true);
-                                       srl[i] = (lhs == canonicalize_clifford(sum));
+                                       i->second = canonicalize_clifford(sum);
                                        goto next_sym;
                                }
                                ++it;
index 1d9fa8794c9b70012d66765755ff1d946478359a..2f5e8fe9d851a6e4c4e70964b2339f4b32f98794 100644 (file)
@@ -170,8 +170,10 @@ public:
 
        // rational functions
        ex normal(int level = 0) const;
-       ex to_rational(lst &repl_lst) const;
-       ex to_polynomial(lst &repl_lst) const;
+       ex to_rational(exmap & repl) const;
+       ex to_rational(lst & repl_lst) const;
+       ex to_polynomial(exmap & repl) const;
+       ex to_polynomial(lst & repl_lst) const;
        ex numer() const;
        ex denom() const;
        ex numer_denom() const;
@@ -681,6 +683,23 @@ inline bool are_ex_trivially_equal(const ex &e1, const ex &e2)
        return e1.bp == e2.bp;
 }
 
+/* Function objects for STL sort() etc. */
+struct ex_is_less : public std::binary_function<ex, ex, bool> {
+       bool operator() (const ex &lh, const ex &rh) const { return lh.compare(rh) < 0; }
+};
+
+struct ex_is_equal : public std::binary_function<ex, ex, bool> {
+       bool operator() (const ex &lh, const ex &rh) const { return lh.is_equal(rh); }
+};
+
+struct op0_is_equal : public std::binary_function<ex, ex, bool> {
+       bool operator() (const ex &lh, const ex &rh) const { return lh.op(0).is_equal(rh.op(0)); }
+};
+
+struct ex_swap : public std::binary_function<ex, ex, void> {
+       void operator() (ex &lh, ex &rh) const { lh.swap(rh); }
+};
+
 // wrapper functions around member functions
 inline size_t nops(const ex & thisex)
 { return thisex.nops(); }
@@ -718,6 +737,12 @@ inline ex normal(const ex & thisex, int level=0)
 inline ex to_rational(const ex & thisex, lst & repl_lst)
 { return thisex.to_rational(repl_lst); }
 
+inline ex to_rational(const ex & thisex, exmap & repl)
+{ return thisex.to_rational(repl); }
+
+inline ex to_polynomial(const ex & thisex, exmap & repl)
+{ return thisex.to_polynomial(repl); }
+
 inline ex to_polynomial(const ex & thisex, lst & repl_lst)
 { return thisex.to_polynomial(repl_lst); }
 
@@ -781,23 +806,6 @@ inline bool is_zero(const ex & thisex)
 inline void swap(ex & e1, ex & e2)
 { e1.swap(e2); }
 
-/* Function objects for STL sort() etc. */
-struct ex_is_less : public std::binary_function<ex, ex, bool> {
-       bool operator() (const ex &lh, const ex &rh) const { return lh.compare(rh) < 0; }
-};
-
-struct ex_is_equal : public std::binary_function<ex, ex, bool> {
-       bool operator() (const ex &lh, const ex &rh) const { return lh.is_equal(rh); }
-};
-
-struct op0_is_equal : public std::binary_function<ex, ex, bool> {
-       bool operator() (const ex &lh, const ex &rh) const { return lh.op(0).is_equal(rh.op(0)); }
-};
-
-struct ex_swap : public std::binary_function<ex, ex, void> {
-       void operator() (ex &lh, ex &rh) const { lh.swap(rh); }
-};
-
 inline ex ex::subs(const exmap & m, unsigned options) const
 {
        return bp->subs(m, options);
index f789514fe02bdf243f85b24494d2150f2beebefc..96666b86eb9ef38e6197f6949899e05bf558f146 100644 (file)
@@ -77,8 +77,8 @@ public:
        ex op(size_t i) const;
        ex map(map_function & f) const;
        ex eval(int level=0) const;
-       ex to_rational(lst &repl_lst) const;
-       ex to_polynomial(lst &repl_lst) const;
+       ex to_rational(exmap & repl) const;
+       ex to_polynomial(exmap & repl) const;
        bool match(const ex & pattern, lst & repl_lst) const;
        ex subs(const exmap & m, unsigned options = 0) const;
 protected:
index b9193a6cd1caa488eba441a902c15373803547a3..9dc46de92776ff3a8988d40e76b92e10c6effe03 100644 (file)
@@ -702,7 +702,7 @@ ex matrix::determinant(unsigned algo) const
        unsigned sparse_count = 0;  // counts non-zero elements
        exvector::const_iterator r = m.begin(), rend = m.end();
        while (r != rend) {
-               lst srl;  // symbol replacement list
+               exmap srl;  // symbol replacement list
                ex rtest = r->to_rational(srl);
                if (!rtest.is_zero())
                        ++sparse_count;
@@ -1320,7 +1320,7 @@ int matrix::fraction_free_elimination(const bool det)
        // makes things more complicated than they need to be.
        matrix tmp_n(*this);
        matrix tmp_d(m,n);  // for denominators, if needed
-       lst srl;  // symbol replacement list
+       exmap srl;  // symbol replacement list
        exvector::const_iterator cit = this->m.begin(), citend = this->m.end();
        exvector::iterator tmp_n_it = tmp_n.m.begin(), tmp_d_it = tmp_d.m.begin();
        while (cit != citend) {
index 8568cc3aa54310c3b632f98f2661395c050c53e9..15982a038ab5c0a2ef86183191d5049b995e2ef9 100644 (file)
@@ -1702,23 +1702,23 @@ static ex replace_with_symbol(const ex & e, exmap & repl, exmap & rev_lookup)
 }
 
 /** Create a symbol for replacing the expression "e" (or return a previously
- *  assigned symbol). An expression of the form "symbol == expression" is added
- *  to repl_lst and the symbol is returned.
+ *  assigned symbol). The symbol and expression are appended to repl, and the
+ *  symbol is returned.
  *  @see basic::to_rational
  *  @see basic::to_polynomial */
-static ex replace_with_symbol(const ex & e, lst & repl_lst)
+static ex replace_with_symbol(const ex & e, exmap & repl)
 {
-       // Expression already in repl_lst? Then return the assigned symbol
-       for (lst::const_iterator it = repl_lst.begin(); it != repl_lst.end(); ++it)
-               if (it->op(1).is_equal(e))
-                       return it->op(0);
+       // Expression already replaced? Then return the assigned symbol
+       for (exmap::const_iterator it = repl.begin(); it != repl.end(); ++it)
+               if (it->second.is_equal(e))
+                       return it->first;
        
        // Otherwise create new symbol and add to list, taking care that the
-       // replacement expression doesn't itself contain symbols from the repl_lst,
+       // replacement expression doesn't itself contain symbols from repl,
        // because subs() is not recursive
        ex es = (new symbol)->setflag(status_flags::dynallocated);
-       ex e_replaced = e.subs(repl_lst, subs_options::no_pattern);
-       repl_lst.append(es == e_replaced);
+       ex e_replaced = e.subs(repl, subs_options::no_pattern);
+       repl.insert(std::make_pair(es, e_replaced));
        return es;
 }
 
@@ -2103,46 +2103,80 @@ ex ex::numer_denom() const
  *  on non-rational functions by applying to_rational() on the arguments,
  *  calling the desired function and re-substituting the temporary symbols
  *  in the result. To make the last step possible, all temporary symbols and
- *  their associated expressions are collected in the list specified by the
- *  repl_lst parameter in the form {symbol == expression}, ready to be passed
- *  as an argument to ex::subs().
+ *  their associated expressions are collected in the map specified by the
+ *  repl parameter, ready to be passed as an argument to ex::subs().
  *
- *  @param repl_lst collects a list of all temporary symbols and their replacements
+ *  @param repl collects all temporary symbols and their replacements
  *  @return rationalized expression */
-ex ex::to_rational(lst &repl_lst) const
+ex ex::to_rational(exmap & repl) const
 {
-       return bp->to_rational(repl_lst);
+       return bp->to_rational(repl);
+}
+
+// GiNaC 1.1 compatibility function
+ex ex::to_rational(lst & repl_lst) const
+{
+       // Convert lst to exmap
+       exmap m;
+       for (lst::const_iterator it = repl_lst.begin(); it != repl_lst.end(); ++it)
+               m.insert(std::make_pair(it->op(0), it->op(1)));
+
+       ex ret = bp->to_rational(m);
+
+       // Convert exmap back to lst
+       repl_lst.remove_all();
+       for (exmap::const_iterator it = m.begin(); it != m.end(); ++it)
+               repl_lst.append(it->first == it->second);
+
+       return ret;
 }
 
-ex ex::to_polynomial(lst &repl_lst) const
+ex ex::to_polynomial(exmap & repl) const
 {
-       return bp->to_polynomial(repl_lst);
+       return bp->to_polynomial(repl);
 }
 
+// GiNaC 1.1 compatibility function
+ex ex::to_polynomial(lst & repl_lst) const
+{
+       // Convert lst to exmap
+       exmap m;
+       for (lst::const_iterator it = repl_lst.begin(); it != repl_lst.end(); ++it)
+               m.insert(std::make_pair(it->op(0), it->op(1)));
+
+       ex ret = bp->to_polynomial(m);
+
+       // Convert exmap back to lst
+       repl_lst.remove_all();
+       for (exmap::const_iterator it = m.begin(); it != m.end(); ++it)
+               repl_lst.append(it->first == it->second);
+
+       return ret;
+}
 
 /** Default implementation of ex::to_rational(). This replaces the object with
  *  a temporary symbol. */
-ex basic::to_rational(lst &repl_lst) const
+ex basic::to_rational(exmap & repl) const
 {
-       return replace_with_symbol(*this, repl_lst);
+       return replace_with_symbol(*this, repl);
 }
 
-ex basic::to_polynomial(lst &repl_lst) const
+ex basic::to_polynomial(exmap & repl) const
 {
-       return replace_with_symbol(*this, repl_lst);
+       return replace_with_symbol(*this, repl);
 }
 
 
 /** Implementation of ex::to_rational() for symbols. This returns the
  *  unmodified symbol. */
-ex symbol::to_rational(lst &repl_lst) const
+ex symbol::to_rational(exmap & repl) const
 {
        return *this;
 }
 
 /** Implementation of ex::to_polynomial() for symbols. This returns the
  *  unmodified symbol. */
-ex symbol::to_polynomial(lst &repl_lst) const
+ex symbol::to_polynomial(exmap & repl) const
 {
        return *this;
 }
@@ -2151,17 +2185,17 @@ ex symbol::to_polynomial(lst &repl_lst) const
 /** Implementation of ex::to_rational() for a numeric. It splits complex
  *  numbers into re+I*im and replaces I and non-rational real numbers with a
  *  temporary symbol. */
-ex numeric::to_rational(lst &repl_lst) const
+ex numeric::to_rational(exmap & repl) const
 {
        if (is_real()) {
                if (!is_rational())
-                       return replace_with_symbol(*this, repl_lst);
+                       return replace_with_symbol(*this, repl);
        } else { // complex
                numeric re = real();
                numeric im = imag();
-               ex re_ex = re.is_rational() ? re : replace_with_symbol(re, repl_lst);
-               ex im_ex = im.is_rational() ? im : replace_with_symbol(im, repl_lst);
-               return re_ex + im_ex * replace_with_symbol(I, repl_lst);
+               ex re_ex = re.is_rational() ? re : replace_with_symbol(re, repl);
+               ex im_ex = im.is_rational() ? im : replace_with_symbol(im, repl);
+               return re_ex + im_ex * replace_with_symbol(I, repl);
        }
        return *this;
 }
@@ -2169,17 +2203,17 @@ ex numeric::to_rational(lst &repl_lst) const
 /** Implementation of ex::to_polynomial() for a numeric. It splits complex
  *  numbers into re+I*im and replaces I and non-integer real numbers with a
  *  temporary symbol. */
-ex numeric::to_polynomial(lst &repl_lst) const
+ex numeric::to_polynomial(exmap & repl) const
 {
        if (is_real()) {
                if (!is_integer())
-                       return replace_with_symbol(*this, repl_lst);
+                       return replace_with_symbol(*this, repl);
        } else { // complex
                numeric re = real();
                numeric im = imag();
-               ex re_ex = re.is_integer() ? re : replace_with_symbol(re, repl_lst);
-               ex im_ex = im.is_integer() ? im : replace_with_symbol(im, repl_lst);
-               return re_ex + im_ex * replace_with_symbol(I, repl_lst);
+               ex re_ex = re.is_integer() ? re : replace_with_symbol(re, repl);
+               ex im_ex = im.is_integer() ? im : replace_with_symbol(im, repl);
+               return re_ex + im_ex * replace_with_symbol(I, repl);
        }
        return *this;
 }
@@ -2187,36 +2221,36 @@ ex numeric::to_polynomial(lst &repl_lst) const
 
 /** Implementation of ex::to_rational() for powers. It replaces non-integer
  *  powers by temporary symbols. */
-ex power::to_rational(lst &repl_lst) const
+ex power::to_rational(exmap & repl) const
 {
        if (exponent.info(info_flags::integer))
-               return power(basis.to_rational(repl_lst), exponent);
+               return power(basis.to_rational(repl), exponent);
        else
-               return replace_with_symbol(*this, repl_lst);
+               return replace_with_symbol(*this, repl);
 }
 
 /** Implementation of ex::to_polynomial() for powers. It replaces non-posint
  *  powers by temporary symbols. */
-ex power::to_polynomial(lst &repl_lst) const
+ex power::to_polynomial(exmap & repl) const
 {
        if (exponent.info(info_flags::posint))
-               return power(basis.to_rational(repl_lst), exponent);
+               return power(basis.to_rational(repl), exponent);
        else
-               return replace_with_symbol(*this, repl_lst);
+               return replace_with_symbol(*this, repl);
 }
 
 
 /** Implementation of ex::to_rational() for expairseqs. */
-ex expairseq::to_rational(lst &repl_lst) const
+ex expairseq::to_rational(exmap & repl) const
 {
        epvector s;
        s.reserve(seq.size());
        epvector::const_iterator i = seq.begin(), end = seq.end();
        while (i != end) {
-               s.push_back(split_ex_to_pair(recombine_pair_to_ex(*i).to_rational(repl_lst)));
+               s.push_back(split_ex_to_pair(recombine_pair_to_ex(*i).to_rational(repl)));
                ++i;
        }
-       ex oc = overall_coeff.to_rational(repl_lst);
+       ex oc = overall_coeff.to_rational(repl);
        if (oc.info(info_flags::numeric))
                return thisexpairseq(s, overall_coeff);
        else
@@ -2225,16 +2259,16 @@ ex expairseq::to_rational(lst &repl_lst) const
 }
 
 /** Implementation of ex::to_polynomial() for expairseqs. */
-ex expairseq::to_polynomial(lst &repl_lst) const
+ex expairseq::to_polynomial(exmap & repl) const
 {
        epvector s;
        s.reserve(seq.size());
        epvector::const_iterator i = seq.begin(), end = seq.end();
        while (i != end) {
-               s.push_back(split_ex_to_pair(recombine_pair_to_ex(*i).to_polynomial(repl_lst)));
+               s.push_back(split_ex_to_pair(recombine_pair_to_ex(*i).to_polynomial(repl)));
                ++i;
        }
-       ex oc = overall_coeff.to_polynomial(repl_lst);
+       ex oc = overall_coeff.to_polynomial(repl);
        if (oc.info(info_flags::numeric))
                return thisexpairseq(s, overall_coeff);
        else
@@ -2246,7 +2280,7 @@ ex expairseq::to_polynomial(lst &repl_lst) const
 /** Remove the common factor in the terms of a sum 'e' by calculating the GCD,
  *  and multiply it into the expression 'factor' (which needs to be initialized
  *  to 1, unless you're accumulating factors). */
-static ex find_common_factor(const ex & e, ex & factor, lst & repl)
+static ex find_common_factor(const ex & e, ex & factor, exmap & repl)
 {
        if (is_exactly_a<add>(e)) {
 
@@ -2331,7 +2365,7 @@ ex collect_common_factors(const ex & e)
 {
        if (is_exactly_a<add>(e) || is_exactly_a<mul>(e)) {
 
-               lst repl;
+               exmap repl;
                ex factor = 1;
                ex r = find_common_factor(e, factor, repl);
                return factor.subs(repl, subs_options::no_pattern) * r.subs(repl, subs_options::no_pattern);
index b7c1e37d0eab208273c4a86c538b94417ea0ae39..45bd853b790808e9c94af6d4fe974282208cfa06 100644 (file)
@@ -105,8 +105,8 @@ public:
        ex evalf(int level = 0) const;
        ex subs(const exmap & m, unsigned options = 0) const { return subs_one_level(m, options); } // overwrites basic::subs() for performance reasons
        ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const;
-       ex to_rational(lst &repl_lst) const;
-       ex to_polynomial(lst &repl_lst) const;
+       ex to_rational(exmap & repl) const;
+       ex to_polynomial(exmap & repl) const;
        numeric integer_content() const;
        ex smod(const numeric &xi) const;
        numeric max_coefficient() const;
index 4fdbf44d593f9841234ccf5938e71168f02b7a7d..c60ad4e61ac08feee4770b9c63fc664cf80aa3c9 100644 (file)
@@ -62,8 +62,8 @@ public:
        ex series(const relational & s, int order, unsigned options = 0) const;
        ex subs(const exmap & m, unsigned options = 0) const;
        ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const;
-       ex to_rational(lst &repl_lst) const;
-       ex to_polynomial(lst &repl_lst) const;
+       ex to_rational(exmap & repl) const;
+       ex to_polynomial(exmap & repl) const;
        exvector get_free_indices() const;
 protected:
        ex derivative(const symbol & s) const;
index 1c28d7501a3fb40c30ef742f372546e5bb90b13a..b929e88caceb61cc2bab30046d1664c77c711d29 100644 (file)
@@ -182,8 +182,8 @@ public:
 
        // rational functions
        ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const { return inherited::normal(repl, rev_lookup, level); }
-       ex to_rational(lst & repl_lst) const { return inherited::to_rational(repl_lst); }
-       ex to_polynomial(lst & repl_lst) const { return inherited::to_polynomial(repl_lst); }
+       ex to_rational(exmap & repl) const { return inherited::to_rational(repl); }
+       ex to_polynomial(exmap & repl) const { return inherited::to_polynomial(repl); }
 
        // polynomial algorithms
        numeric integer_content() const { return 1; }
index ab2d52a5477f78ea93d2dd7e2c51f15ff63fb2ac..0b6844a65d700a98706b104b5ce519a18a456797 100644 (file)
@@ -67,8 +67,8 @@ public:
        ex series(const relational & s, int order, unsigned options = 0) const;
        ex subs(const exmap & m, unsigned options = 0) const { return subs_one_level(m, options); } // overwrites basic::subs() for performance reasons
        ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const;
-       ex to_rational(lst &repl_lst) const;
-       ex to_polynomial(lst &repl_lst) const;
+       ex to_rational(exmap & repl) const;
+       ex to_polynomial(exmap & repl) const;
        unsigned return_type() const { return ret_type; }
        unsigned return_type_tinfo() const { return ret_type_tinfo; }
 protected: