X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=ac31fcc2b11f9062596904269d7b41212f5cfddb;hp=28307ad73113b0c86f38cd2939a3f03503d7791b;hb=08c190937df7e802393b588d3cc82d2bdf00b128;hpb=6d225ee55693c0617d254e6fa283c00c71bd2919 diff --git a/ginac/ex.cpp b/ginac/ex.cpp index 28307ad7..ac31fcc2 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-2004 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2020 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 @@ -17,23 +17,23 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#include -#include - #include "ex.h" #include "add.h" #include "mul.h" #include "ncmul.h" #include "numeric.h" +#include "matrix.h" #include "power.h" #include "lst.h" #include "relational.h" -#include "input_lexer.h" #include "utils.h" +#include +#include + namespace GiNaC { ////////// @@ -94,7 +94,7 @@ ex ex::diff(const symbol & s, unsigned nth) const /** Check whether expression matches a specified pattern. */ bool ex::match(const ex & pattern) const { - lst repl_lst; + exmap repl_lst; return bp->match(pattern, repl_lst); } @@ -102,12 +102,10 @@ bool ex::match(const ex & pattern) const * 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 +bool ex::find(const ex & pattern, exset& found) const { if (match(pattern)) { - found.append(*this); - found.sort(); - found.unique(); + found.insert(*this); return true; } bool any_found = false; @@ -125,7 +123,7 @@ ex ex::subs(const lst & ls, const lst & lr, unsigned options) const // Convert the lists to a map exmap m; - for (lst::const_iterator its = ls.begin(), itr = lr.begin(); its != ls.end(); ++its, ++itr) { + for (auto its = ls.begin(), itr = lr.begin(); its != ls.end(); ++its, ++itr) { m.insert(std::make_pair(*its, *itr)); // Search for products and powers in the expressions to be substituted @@ -142,7 +140,7 @@ ex ex::subs(const lst & ls, const lst & lr, unsigned options) const /** Substitute objects in an expression (syntactic substitution) and return * the result as a new expression. There are two valid types of * replacement arguments: 1) a relational like object==ex and 2) a list of - * relationals lst(object1==ex1,object2==ex2,...). */ + * relationals lst{object1==ex1,object2==ex2,...}. */ ex ex::subs(const ex & e, unsigned options) const { if (e.info(info_flags::relation_equal)) { @@ -164,8 +162,7 @@ ex ex::subs(const ex & e, unsigned options) const // Argument is a list: convert it to a map exmap m; GINAC_ASSERT(is_a(e)); - for (lst::const_iterator it = ex_to(e).begin(); it != ex_to(e).end(); ++it) { - ex r = *it; + for (auto & r : ex_to(e)) { if (!r.info(info_flags::relation_equal)) throw(std::invalid_argument("basic::subs(ex): argument must be a list of equations")); const ex & s = r.op(0); @@ -205,7 +202,7 @@ void ex::traverse_postorder(visitor & v) const accept(v); } -/** Return modifyable operand/member at position i. */ +/** Return modifiable operand/member at position i. */ ex & ex::let_op(size_t i) { makewriteable(); @@ -240,6 +237,31 @@ ex ex::rhs() const return bp->op(1); } +/** Check whether expression is a polynomial. */ +bool ex::is_polynomial(const ex & vars) const +{ + if (is_a(vars)) { + const lst & varlst = ex_to(vars); + for (auto & it : varlst) + if (!bp->is_polynomial(it)) + return false; + return true; + } + else + return bp->is_polynomial(vars); +} + +/** Check whether expression is zero or zero matrix. */ +bool ex::is_zero_matrix() const +{ + if (is_zero()) + return true; + else { + ex e = evalm(); + return is_a(e) && ex_to(e).is_zero_matrix(); + } +} + // private /** Make this ex writable (if more than one ex handle the same basic) by @@ -284,7 +306,7 @@ ptr ex::construct_from_basic(const basic & other) // apply eval() once more. The recursion stops when eval() calls // hold() or returns an object that already has its "evaluated" // flag set, such as a symbol or a numeric. - const ex & tmpex = other.eval(1); + const ex & tmpex = other.eval(); // Eventually, the eval() recursion goes through the "else" branch // below, which assures that the object pointed to by tmpex.bp is @@ -329,60 +351,57 @@ basic & ex::construct_from_int(int i) { switch (i) { // prefer flyweights over new objects case -12: - return const_cast(_num_12); + return *const_cast(_num_12_p); case -11: - return const_cast(_num_11); + return *const_cast(_num_11_p); case -10: - return const_cast(_num_10); + return *const_cast(_num_10_p); case -9: - return const_cast(_num_9); + return *const_cast(_num_9_p); case -8: - return const_cast(_num_8); + return *const_cast(_num_8_p); case -7: - return const_cast(_num_7); + return *const_cast(_num_7_p); case -6: - return const_cast(_num_6); + return *const_cast(_num_6_p); case -5: - return const_cast(_num_5); + return *const_cast(_num_5_p); case -4: - return const_cast(_num_4); + return *const_cast(_num_4_p); case -3: - return const_cast(_num_3); + return *const_cast(_num_3_p); case -2: - return const_cast(_num_2); + return *const_cast(_num_2_p); case -1: - return const_cast(_num_1); + return *const_cast(_num_1_p); case 0: - return const_cast(_num0); + return *const_cast(_num0_p); case 1: - return const_cast(_num1); + return *const_cast(_num1_p); case 2: - return const_cast(_num2); + return *const_cast(_num2_p); case 3: - return const_cast(_num3); + return *const_cast(_num3_p); case 4: - return const_cast(_num4); + return *const_cast(_num4_p); case 5: - return const_cast(_num5); + return *const_cast(_num5_p); case 6: - return const_cast(_num6); + return *const_cast(_num6_p); case 7: - return const_cast(_num7); + return *const_cast(_num7_p); case 8: - return const_cast(_num8); + return *const_cast(_num8_p); case 9: - return const_cast(_num9); + return *const_cast(_num9_p); case 10: - return const_cast(_num10); + return *const_cast(_num10_p); case 11: - return const_cast(_num11); + return *const_cast(_num11_p); case 12: - return const_cast(_num12); + return *const_cast(_num12_p); default: - basic *bp = new numeric(i); - bp->setflag(status_flags::dynallocated); - GINAC_ASSERT(bp->get_refcount() == 0); - return *bp; + return dynallocate(i); } } @@ -390,36 +409,33 @@ basic & ex::construct_from_uint(unsigned int i) { switch (i) { // prefer flyweights over new objects case 0: - return const_cast(_num0); + return *const_cast(_num0_p); case 1: - return const_cast(_num1); + return *const_cast(_num1_p); case 2: - return const_cast(_num2); + return *const_cast(_num2_p); case 3: - return const_cast(_num3); + return *const_cast(_num3_p); case 4: - return const_cast(_num4); + return *const_cast(_num4_p); case 5: - return const_cast(_num5); + return *const_cast(_num5_p); case 6: - return const_cast(_num6); + return *const_cast(_num6_p); case 7: - return const_cast(_num7); + return *const_cast(_num7_p); case 8: - return const_cast(_num8); + return *const_cast(_num8_p); case 9: - return const_cast(_num9); + return *const_cast(_num9_p); case 10: - return const_cast(_num10); + return *const_cast(_num10_p); case 11: - return const_cast(_num11); + return *const_cast(_num11_p); case 12: - return const_cast(_num12); + return *const_cast(_num12_p); default: - basic *bp = new numeric(i); - bp->setflag(status_flags::dynallocated); - GINAC_ASSERT(bp->get_refcount() == 0); - return *bp; + return dynallocate(i); } } @@ -427,60 +443,57 @@ basic & ex::construct_from_long(long i) { switch (i) { // prefer flyweights over new objects case -12: - return const_cast(_num_12); + return *const_cast(_num_12_p); case -11: - return const_cast(_num_11); + return *const_cast(_num_11_p); case -10: - return const_cast(_num_10); + return *const_cast(_num_10_p); case -9: - return const_cast(_num_9); + return *const_cast(_num_9_p); case -8: - return const_cast(_num_8); + return *const_cast(_num_8_p); case -7: - return const_cast(_num_7); + return *const_cast(_num_7_p); case -6: - return const_cast(_num_6); + return *const_cast(_num_6_p); case -5: - return const_cast(_num_5); + return *const_cast(_num_5_p); case -4: - return const_cast(_num_4); + return *const_cast(_num_4_p); case -3: - return const_cast(_num_3); + return *const_cast(_num_3_p); case -2: - return const_cast(_num_2); + return *const_cast(_num_2_p); case -1: - return const_cast(_num_1); + return *const_cast(_num_1_p); case 0: - return const_cast(_num0); + return *const_cast(_num0_p); case 1: - return const_cast(_num1); + return *const_cast(_num1_p); case 2: - return const_cast(_num2); + return *const_cast(_num2_p); case 3: - return const_cast(_num3); + return *const_cast(_num3_p); case 4: - return const_cast(_num4); + return *const_cast(_num4_p); case 5: - return const_cast(_num5); + return *const_cast(_num5_p); case 6: - return const_cast(_num6); + return *const_cast(_num6_p); case 7: - return const_cast(_num7); + return *const_cast(_num7_p); case 8: - return const_cast(_num8); + return *const_cast(_num8_p); case 9: - return const_cast(_num9); + return *const_cast(_num9_p); case 10: - return const_cast(_num10); + return *const_cast(_num10_p); case 11: - return const_cast(_num11); + return *const_cast(_num11_p); case 12: - return const_cast(_num12); + return *const_cast(_num12_p); default: - basic *bp = new numeric(i); - bp->setflag(status_flags::dynallocated); - GINAC_ASSERT(bp->get_refcount() == 0); - return *bp; + return dynallocate(i); } } @@ -488,58 +501,59 @@ basic & ex::construct_from_ulong(unsigned long i) { switch (i) { // prefer flyweights over new objects case 0: - return const_cast(_num0); + return *const_cast(_num0_p); case 1: - return const_cast(_num1); + return *const_cast(_num1_p); case 2: - return const_cast(_num2); + return *const_cast(_num2_p); case 3: - return const_cast(_num3); + return *const_cast(_num3_p); case 4: - return const_cast(_num4); + return *const_cast(_num4_p); case 5: - return const_cast(_num5); + return *const_cast(_num5_p); case 6: - return const_cast(_num6); + return *const_cast(_num6_p); case 7: - return const_cast(_num7); + return *const_cast(_num7_p); case 8: - return const_cast(_num8); + return *const_cast(_num8_p); case 9: - return const_cast(_num9); + return *const_cast(_num9_p); case 10: - return const_cast(_num10); + return *const_cast(_num10_p); case 11: - return const_cast(_num11); + return *const_cast(_num11_p); case 12: - return const_cast(_num12); + return *const_cast(_num12_p); default: - basic *bp = new numeric(i); - bp->setflag(status_flags::dynallocated); - GINAC_ASSERT(bp->get_refcount() == 0); - return *bp; + return dynallocate(i); } } - -basic & ex::construct_from_double(double d) + +basic & ex::construct_from_longlong(long long i) { - basic *bp = new numeric(d); - bp->setflag(status_flags::dynallocated); - GINAC_ASSERT(bp->get_refcount() == 0); - return *bp; + if (i >= -12 && i <= 12) { + return construct_from_int(static_cast(i)); + } else { + return dynallocate(i); + } } -ptr ex::construct_from_string_and_lst(const std::string &s, const ex &l) +basic & ex::construct_from_ulonglong(unsigned long long i) { - set_lexer_string(s); - set_lexer_symbols(l); - ginac_yyrestart(NULL); - if (ginac_yyparse()) - throw (std::runtime_error(get_parser_error())); - else - return parsed_ex.bp; + if (i <= 12) { + return construct_from_uint(static_cast(i)); + } else { + return dynallocate(i); + } } - + +basic & ex::construct_from_double(double d) +{ + return dynallocate(d); +} + ////////// // static member variables //////////