X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Finifcns.cpp;h=e2a09b161ccf95ad01e3f95f07b823b79d2b2e54;hp=9cb5f676118058067112a5fd18d06d9a060d01f5;hb=8cffcdf13d817a47f217f1a1043317d95969e070;hpb=34f23dc638fba5905a1edb3ebcaf99d6eedabf3c

diff --git a/ginac/inifcns.cpp b/ginac/inifcns.cpp
index 9cb5f676..e2a09b16 100644
--- a/ginac/inifcns.cpp
+++ b/ginac/inifcns.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's initially known functions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2015 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2019 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
@@ -109,7 +109,6 @@ static bool func_arg_info(const ex & arg, unsigned inf)
 		case info_flags::prime:
 		case info_flags::crational_polynomial:
 		case info_flags::rational_function:
-		case info_flags::algebraic:
 		case info_flags::positive:
 		case info_flags::negative:
 		case info_flags::nonnegative:
@@ -310,7 +309,7 @@ static ex abs_expand(const ex & arg, unsigned options)
 			else
 				prodseq.push_back(abs(*i));
 		}
-		return (new mul(prodseq))->setflag(status_flags::dynallocated | status_flags::expanded);
+		return dynallocate<mul>(prodseq).setflag(status_flags::expanded);
 	}
 
 	if (options & expand_options::expand_function_args)
@@ -354,9 +353,9 @@ static ex abs_power(const ex & arg, const ex & exp)
 {
 	if ((is_a<numeric>(exp) && ex_to<numeric>(exp).is_even()) || exp.info(info_flags::even)) {
 		if (arg.info(info_flags::real) || arg.is_equal(arg.conjugate()))
-			return power(arg, exp);
+			return pow(arg, exp);
 		else
-			return power(arg, exp/2)*power(arg.conjugate(), exp/2);
+			return pow(arg, exp/2) * pow(arg.conjugate(), exp/2);
 	} else
 		return power(abs(arg), exp).hold();
 }
@@ -1039,13 +1038,31 @@ REGISTER_FUNCTION(Order, eval_func(Order_eval).
 // Solve linear system
 //////////
 
+static void insert_symbols(exset &es, const ex &e)
+{
+	if (is_a<symbol>(e)) {
+		es.insert(e);
+	} else {
+		for (const ex &sube : e) {
+			insert_symbols(es, sube);
+		}
+	}
+}
+
+static exset symbolset(const ex &e)
+{
+	exset s;
+	insert_symbols(s, e);
+	return s;
+}
+
 ex lsolve(const ex &eqns, const ex &symbols, unsigned options)
 {
 	// solve a system of linear equations
 	if (eqns.info(info_flags::relation_equal)) {
 		if (!symbols.info(info_flags::symbol))
 			throw(std::invalid_argument("lsolve(): 2nd argument must be a symbol"));
-		const ex sol = lsolve(lst(eqns),lst(symbols));
+		const ex sol = lsolve(lst{eqns}, lst{symbols});
 		
 		GINAC_ASSERT(sol.nops()==1);
 		GINAC_ASSERT(is_exactly_a<relational>(sol.op(0)));
@@ -1054,20 +1071,20 @@ ex lsolve(const ex &eqns, const ex &symbols, unsigned options)
 	}
 	
 	// syntax checks
-	if (!eqns.info(info_flags::list)) {
-		throw(std::invalid_argument("lsolve(): 1st argument must be a list or an equation"));
+	if (!(eqns.info(info_flags::list) || eqns.info(info_flags::exprseq))) {
+		throw(std::invalid_argument("lsolve(): 1st argument must be a list, a sequence, or an equation"));
 	}
 	for (size_t i=0; i<eqns.nops(); i++) {
 		if (!eqns.op(i).info(info_flags::relation_equal)) {
 			throw(std::invalid_argument("lsolve(): 1st argument must be a list of equations"));
 		}
 	}
-	if (!symbols.info(info_flags::list)) {
-		throw(std::invalid_argument("lsolve(): 2nd argument must be a list or a symbol"));
+	if (!(symbols.info(info_flags::list) || symbols.info(info_flags::exprseq))) {
+		throw(std::invalid_argument("lsolve(): 2nd argument must be a list, a sequence, or a symbol"));
 	}
 	for (size_t i=0; i<symbols.nops(); i++) {
 		if (!symbols.op(i).info(info_flags::symbol)) {
-			throw(std::invalid_argument("lsolve(): 2nd argument must be a list of symbols"));
+			throw(std::invalid_argument("lsolve(): 2nd argument must be a list or a sequence of symbols"));
 		}
 	}
 	
@@ -1078,8 +1095,10 @@ ex lsolve(const ex &eqns, const ex &symbols, unsigned options)
 	
 	for (size_t r=0; r<eqns.nops(); r++) {
 		const ex eq = eqns.op(r).op(0)-eqns.op(r).op(1); // lhs-rhs==0
+		const exset syms = symbolset(eq);
 		ex linpart = eq;
 		for (size_t c=0; c<symbols.nops(); c++) {
+			if (syms.count(symbols.op(c)) == 0) continue;
 			const ex co = eq.coeff(ex_to<symbol>(symbols.op(c)),1);
 			linpart -= co*symbols.op(c);
 			sys(r,c) = co;
@@ -1089,11 +1108,13 @@ ex lsolve(const ex &eqns, const ex &symbols, unsigned options)
 	}
 	
 	// test if system is linear and fill vars matrix
+	const exset sys_syms = symbolset(sys);
+	const exset rhs_syms = symbolset(rhs);
 	for (size_t i=0; i<symbols.nops(); i++) {
 		vars(i,0) = symbols.op(i);
-		if (sys.has(symbols.op(i)))
+		if (sys_syms.count(symbols.op(i)) != 0)
 			throw(std::logic_error("lsolve: system is not linear"));
-		if (rhs.has(symbols.op(i)))
+		if (rhs_syms.count(symbols.op(i)) != 0)
 			throw(std::logic_error("lsolve: system is not linear"));
 	}
 	
@@ -1103,12 +1124,12 @@ ex lsolve(const ex &eqns, const ex &symbols, unsigned options)
 	} catch (const std::runtime_error & e) {
 		// Probably singular matrix or otherwise overdetermined system:
 		// It is consistent to return an empty list
-		return lst();
+		return lst{};
 	}
 	GINAC_ASSERT(solution.cols()==1);
 	GINAC_ASSERT(solution.rows()==symbols.nops());
 	
-	// return list of equations of the form lst(var1==sol1,var2==sol2,...)
+	// return list of equations of the form lst{var1==sol1,var2==sol2,...}
 	lst sollist;
 	for (size_t i=0; i<symbols.nops(); i++)
 		sollist.append(symbols.op(i)==solution(i,0));