X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fncmul.cpp;h=f086e49235568573d19f5513dad93b930c8e79c6;hp=ccae3488a0a43dda0331eed9c3d3a2d538c860fa;hb=8cffcdf13d817a47f217f1a1043317d95969e070;hpb=0052e44b34c982b13b08454fd6c9429fe7a90f71

diff --git a/ginac/ncmul.cpp b/ginac/ncmul.cpp
index ccae3488..f086e492 100644
--- a/ginac/ncmul.cpp
+++ b/ginac/ncmul.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's non-commutative products of expressions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2016 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
@@ -57,34 +57,34 @@ ncmul::ncmul()
 
 // public
 
-ncmul::ncmul(const ex & lh, const ex & rh) : inherited(lh,rh)
+ncmul::ncmul(const ex & lh, const ex & rh) : inherited{lh,rh}
 {
 }
 
-ncmul::ncmul(const ex & f1, const ex & f2, const ex & f3) : inherited(f1,f2,f3)
+ncmul::ncmul(const ex & f1, const ex & f2, const ex & f3) : inherited{f1,f2,f3}
 {
 }
 
 ncmul::ncmul(const ex & f1, const ex & f2, const ex & f3,
-             const ex & f4) : inherited(f1,f2,f3,f4)
+             const ex & f4) : inherited{f1,f2,f3,f4}
 {
 }
 
 ncmul::ncmul(const ex & f1, const ex & f2, const ex & f3,
-             const ex & f4, const ex & f5) : inherited(f1,f2,f3,f4,f5)
+             const ex & f4, const ex & f5) : inherited{f1,f2,f3,f4,f5}
 {
 }
 
 ncmul::ncmul(const ex & f1, const ex & f2, const ex & f3,
-             const ex & f4, const ex & f5, const ex & f6) : inherited(f1,f2,f3,f4,f5,f6)
+             const ex & f4, const ex & f5, const ex & f6) : inherited{f1,f2,f3,f4,f5,f6}
 {
 }
 
-ncmul::ncmul(const exvector & v, bool discardable) : inherited(v,discardable)
+ncmul::ncmul(const exvector & v) : inherited(v)
 {
 }
 
-ncmul::ncmul(std::auto_ptr<exvector> vp) : inherited(vp)
+ncmul::ncmul(exvector && v) : inherited(std::move(v))
 {
 }
 
@@ -120,8 +120,8 @@ typedef std::vector<std::size_t> uintvector;
 ex ncmul::expand(unsigned options) const
 {
 	// First, expand the children
-	std::auto_ptr<exvector> vp = expandchildren(options);
-	const exvector &expanded_seq = vp.get() ? *vp : this->seq;
+	exvector v = expandchildren(options);
+	const exvector &expanded_seq = v.empty() ? this->seq : v;
 	
 	// Now, look for all the factors that are sums and remember their
 	// position and number of terms.
@@ -132,11 +132,10 @@ ex ncmul::expand(unsigned options) const
 	size_t number_of_expanded_terms = 1;
 
 	size_t current_position = 0;
-	exvector::const_iterator last = expanded_seq.end();
-	for (exvector::const_iterator cit=expanded_seq.begin(); cit!=last; ++cit) {
-		if (is_exactly_a<add>(*cit)) {
+	for (auto & it : expanded_seq) {
+		if (is_exactly_a<add>(it)) {
 			positions_of_adds[number_of_adds] = current_position;
-			size_t num_ops = cit->nops();
+			size_t num_ops = it.nops();
 			number_of_add_operands[number_of_adds] = num_ops;
 			number_of_expanded_terms *= num_ops;
 			number_of_adds++;
@@ -146,9 +145,8 @@ ex ncmul::expand(unsigned options) const
 
 	// If there are no sums, we are done
 	if (number_of_adds == 0) {
-		if (vp.get())
-			return (new ncmul(vp))->
-			        setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
+		if (!v.empty())
+			return dynallocate<ncmul>(std::move(v)).setflag(options == 0 ? status_flags::expanded : 0);
 		else
 			return *this;
 	}
@@ -180,8 +178,7 @@ ex ncmul::expand(unsigned options) const
 			term[positions_of_adds[i]] = rename_dummy_indices_uniquely(va, expanded_seq[positions_of_adds[i]].op(k[i]), true);
 		}
 
-		distrseq.push_back((new ncmul(term, true))->
-		                    setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0)));
+		distrseq.push_back(dynallocate<ncmul>(std::move(term)).setflag(options == 0 ? status_flags::expanded : 0));
 
 		// increment k[]
 		int l = number_of_adds-1;
@@ -193,8 +190,7 @@ ex ncmul::expand(unsigned options) const
 			break;
 	}
 
-	return (new add(distrseq))->
-	        setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
+	return dynallocate<add>(distrseq).setflag(options == 0 ? status_flags::expanded : 0);
 }
 
 int ncmul::degree(const ex & s) const
@@ -204,11 +200,8 @@ int ncmul::degree(const ex & s) const
 
 	// Sum up degrees of factors
 	int deg_sum = 0;
-	exvector::const_iterator i = seq.begin(), end = seq.end();
-	while (i != end) {
-		deg_sum += i->degree(s);
-		++i;
-	}
+	for (auto & i : seq)
+		deg_sum += i.degree(s);
 	return deg_sum;
 }
 
@@ -219,11 +212,8 @@ int ncmul::ldegree(const ex & s) const
 
 	// Sum up degrees of factors
 	int deg_sum = 0;
-	exvector::const_iterator i = seq.begin(), end = seq.end();
-	while (i != end) {
-		deg_sum += i->degree(s);
-		++i;
-	}
+	for (auto & i : seq)
+		deg_sum += i.degree(s);
 	return deg_sum;
 }
 
@@ -238,28 +228,24 @@ ex ncmul::coeff(const ex & s, int n) const
 	if (n == 0) {
 		// product of individual coeffs
 		// if a non-zero power of s is found, the resulting product will be 0
-		exvector::const_iterator it=seq.begin();
-		while (it!=seq.end()) {
-			coeffseq.push_back((*it).coeff(s,n));
-			++it;
-		}
-		return (new ncmul(coeffseq,1))->setflag(status_flags::dynallocated);
+		for (auto & it : seq)
+			coeffseq.push_back(it.coeff(s,n));
+		return dynallocate<ncmul>(std::move(coeffseq));
 	}
 		 
-	exvector::const_iterator i = seq.begin(), end = seq.end();
 	bool coeff_found = false;
-	while (i != end) {
-		ex c = i->coeff(s,n);
+	for (auto & i : seq) {
+		ex c = i.coeff(s,n);
 		if (c.is_zero()) {
-			coeffseq.push_back(*i);
+			coeffseq.push_back(i);
 		} else {
 			coeffseq.push_back(c);
 			coeff_found = true;
 		}
-		++i;
 	}
 
-	if (coeff_found) return (new ncmul(coeffseq,1))->setflag(status_flags::dynallocated);
+	if (coeff_found)
+		return dynallocate<ncmul>(std::move(coeffseq));
 	
 	return _ex0;
 }
@@ -299,9 +285,8 @@ typedef std::vector<exvector> exvectorvector;
  *  - ncmul(...,c1,...,c2,...) -> *(c1,c2,ncmul(...))  (pull out commutative elements)
  *  - ncmul(x1,y1,x2,y2) -> *(ncmul(x1,x2),ncmul(y1,y2))  (collect elements of same type)
  *  - ncmul(x1,x2,x3,...) -> x::eval_ncmul(x1,x2,x3,...)
- *
- *  @param level cut-off in recursive evaluation */
-ex ncmul::eval(int level) const
+ */
+ex ncmul::eval() const
 {
 	// The following additional rule would be nice, but produces a recursion,
 	// which must be trapped by introducing a flag that the sub-ncmuls()
@@ -310,25 +295,21 @@ ex ncmul::eval(int level) const
 	//                      ncmul(ncmul(x1,x2,...),X,ncmul(y1,y2,...)
 	//                      (X noncommutative_composite)
 
-	if ((level==1) && (flags & status_flags::evaluated)) {
+	if (flags & status_flags::evaluated) {
 		return *this;
 	}
 
-	exvector evaledseq=evalchildren(level);
-
 	// ncmul(...,*(x1,x2),...,ncmul(x3,x4),...) ->
 	//     ncmul(...,x1,x2,...,x3,x4,...)  (associativity)
 	size_t factors = 0;
-	exvector::const_iterator cit = evaledseq.begin(), citend = evaledseq.end();
-	while (cit != citend)
-		factors += count_factors(*cit++);
+	for (auto & it : seq)
+		factors += count_factors(it);
 	
 	exvector assocseq;
 	assocseq.reserve(factors);
-	cit = evaledseq.begin();
-	make_flat_inserter mf(evaledseq, true);
-	while (cit != citend)
-	{	ex factor = mf.handle_factor(*(cit++), 1);
+	make_flat_inserter mf(seq, true);
+	for (auto & it : seq) {
+		ex factor = mf.handle_factor(it, 1);
 		append_factors(assocseq, factor);
 	}
 	
@@ -344,9 +325,8 @@ ex ncmul::eval(int level) const
 	size_t count_commutative=0;
 	size_t count_noncommutative=0;
 	size_t count_noncommutative_composite=0;
-	cit = assocseq.begin(); citend = assocseq.end();
-	while (cit != citend) {
-		rettypes[i] = cit->return_type();
+	for (auto & it : assocseq) {
+		rettypes[i] = it.return_type();
 		switch (rettypes[i]) {
 		case return_types::commutative:
 			count_commutative++;
@@ -360,7 +340,7 @@ ex ncmul::eval(int level) const
 		default:
 			throw(std::logic_error("ncmul::eval(): invalid return type"));
 		}
-		++i; ++cit;
+		++i;
 	}
 	GINAC_ASSERT(count_commutative+count_noncommutative+count_noncommutative_composite==assocseq.size());
 
@@ -378,8 +358,8 @@ ex ncmul::eval(int level) const
 			else
 				noncommutativeseq.push_back(assocseq[i]);
 		}
-		commutativeseq.push_back((new ncmul(noncommutativeseq,1))->setflag(status_flags::dynallocated));
-		return (new mul(commutativeseq))->setflag(status_flags::dynallocated);
+		commutativeseq.push_back(dynallocate<ncmul>(std::move(noncommutativeseq)));
+		return dynallocate<mul>(std::move(commutativeseq));
 	}
 		
 	// ncmul(x1,y1,x2,y2) -> *(ncmul(x1,x2),ncmul(y1,y2))
@@ -396,14 +376,13 @@ ex ncmul::eval(int level) const
 		evv.reserve(assoc_num);
 		rttinfos.reserve(assoc_num);
 
-		cit = assocseq.begin(), citend = assocseq.end();
-		while (cit != citend) {
-			return_type_t ti = cit->return_type_tinfo();
+		for (auto & it : assocseq) {
+			return_type_t ti = it.return_type_tinfo();
 			size_t rtt_num = rttinfos.size();
 			// search type in vector of known types
 			for (i=0; i<rtt_num; ++i) {
 				if(ti == rttinfos[i]) {
-					evv[i].push_back(*cit);
+					evv[i].push_back(it);
 					break;
 				}
 			}
@@ -412,9 +391,8 @@ ex ncmul::eval(int level) const
 				rttinfos.push_back(ti);
 				evv.push_back(exvector());
 				(evv.end()-1)->reserve(assoc_num);
-				(evv.end()-1)->push_back(*cit);
+				(evv.end()-1)->push_back(it);
 			}
-			++cit;
 		}
 
 		size_t evv_num = evv.size();
@@ -435,28 +413,24 @@ ex ncmul::eval(int level) const
 		exvector splitseq;
 		splitseq.reserve(evv_num);
 		for (i=0; i<evv_num; ++i)
-			splitseq.push_back((new ncmul(evv[i]))->setflag(status_flags::dynallocated));
+			splitseq.push_back(dynallocate<ncmul>(evv[i]));
 		
-		return (new mul(splitseq))->setflag(status_flags::dynallocated);
+		return dynallocate<mul>(splitseq);
 	}
 	
-	return (new ncmul(assocseq))->setflag(status_flags::dynallocated |
-										  status_flags::evaluated);
+	return dynallocate<ncmul>(assocseq).setflag(status_flags::evaluated);
 }
 
 ex ncmul::evalm() const
 {
 	// Evaluate children first
-	std::auto_ptr<exvector> s(new exvector);
-	s->reserve(seq.size());
-	exvector::const_iterator it = seq.begin(), itend = seq.end();
-	while (it != itend) {
-		s->push_back(it->evalm());
-		it++;
-	}
+	exvector s;
+	s.reserve(seq.size());
+	for (auto & it : seq)
+		s.push_back(it.evalm());
 
 	// If there are only matrices, simply multiply them
-	it = s->begin(); itend = s->end();
+	auto it = s.begin(), itend = s.end();
 	if (is_a<matrix>(*it)) {
 		matrix prod(ex_to<matrix>(*it));
 		it++;
@@ -470,17 +444,17 @@ ex ncmul::evalm() const
 	}
 
 no_matrix:
-	return (new ncmul(s))->setflag(status_flags::dynallocated);
+	return dynallocate<ncmul>(std::move(s));
 }
 
 ex ncmul::thiscontainer(const exvector & v) const
 {
-	return (new ncmul(v))->setflag(status_flags::dynallocated);
+	return dynallocate<ncmul>(v);
 }
 
-ex ncmul::thiscontainer(std::auto_ptr<exvector> vp) const
+ex ncmul::thiscontainer(exvector && v) const
 {
-	return (new ncmul(vp))->setflag(status_flags::dynallocated);
+	return dynallocate<ncmul>(std::move(v));
 }
 
 ex ncmul::conjugate() const
@@ -495,11 +469,11 @@ ex ncmul::conjugate() const
 
 	exvector ev;
 	ev.reserve(nops());
-	for (const_iterator i=end(); i!=begin();) {
+	for (auto i=end(); i!=begin();) {
 		--i;
 		ev.push_back(i->conjugate());
 	}
-	return (new ncmul(ev, true))->setflag(status_flags::dynallocated).eval();
+	return dynallocate<ncmul>(std::move(ev));
 }
 
 ex ncmul::real_part() const
@@ -528,10 +502,10 @@ ex ncmul::derivative(const symbol & s) const
 	for (size_t i=0; i<num; ++i) {
 		ex e = seq[i].diff(s);
 		e.swap(ncmulseq[i]);
-		addseq.push_back((new ncmul(ncmulseq))->setflag(status_flags::dynallocated));
+		addseq.push_back(dynallocate<ncmul>(ncmulseq));
 		e.swap(ncmulseq[i]);
 	}
-	return (new add(addseq))->setflag(status_flags::dynallocated);
+	return dynallocate<add>(addseq);
 }
 
 int ncmul::compare_same_type(const basic & other) const
@@ -547,7 +521,7 @@ unsigned ncmul::return_type() const
 	bool all_commutative = true;
 	exvector::const_iterator noncommutative_element; // point to first found nc element
 
-	exvector::const_iterator i = seq.begin(), end = seq.end();
+	auto i = seq.begin(), end = seq.end();
 	while (i != end) {
 		unsigned rt = i->return_type();
 		if (rt == return_types::noncommutative_composite)
@@ -575,12 +549,9 @@ return_type_t ncmul::return_type_tinfo() const
 		return make_return_type_t<ncmul>();
 
 	// return type_info of first noncommutative element
-	exvector::const_iterator i = seq.begin(), end = seq.end();
-	while (i != end) {
-		if (i->return_type() == return_types::noncommutative)
-			return i->return_type_tinfo();
-		++i;
-	}
+	for (auto & i : seq)
+		if (i.return_type() == return_types::noncommutative)
+			return i.return_type_tinfo();
 
 	// no noncommutative element found, should not happen
 	return make_return_type_t<ncmul>();
@@ -596,24 +567,24 @@ return_type_t ncmul::return_type_tinfo() const
 // non-virtual functions in this class
 //////////
 
-std::auto_ptr<exvector> ncmul::expandchildren(unsigned options) const
+exvector ncmul::expandchildren(unsigned options) const
 {
-	const_iterator cit = this->seq.begin(), end = this->seq.end();
+	auto cit = this->seq.begin(), end = this->seq.end();
 	while (cit != end) {
 		const ex & expanded_ex = cit->expand(options);
 		if (!are_ex_trivially_equal(*cit, expanded_ex)) {
 
 			// copy first part of seq which hasn't changed
-			std::auto_ptr<exvector> s(new exvector(this->seq.begin(), cit));
-			reserve(*s, this->seq.size());
+			exvector s(this->seq.begin(), cit);
+			s.reserve(this->seq.size());
 
 			// insert changed element
-			s->push_back(expanded_ex);
+			s.push_back(expanded_ex);
 			++cit;
 
 			// copy rest
 			while (cit != end) {
-				s->push_back(cit->expand(options));
+				s.push_back(cit->expand(options));
 				++cit;
 			}
 
@@ -623,7 +594,7 @@ std::auto_ptr<exvector> ncmul::expandchildren(unsigned options) const
 		++cit;
 	}
 
-	return std::auto_ptr<exvector>(0); // nothing has changed
+	return exvector(); // nothing has changed
 }
 
 const exvector & ncmul::get_factors() const
@@ -637,7 +608,7 @@ const exvector & ncmul::get_factors() const
 
 ex reeval_ncmul(const exvector & v)
 {
-	return (new ncmul(v))->setflag(status_flags::dynallocated);
+	return dynallocate<ncmul>(v);
 }
 
 ex hold_ncmul(const exvector & v)
@@ -647,8 +618,7 @@ ex hold_ncmul(const exvector & v)
 	else if (v.size() == 1)
 		return v[0];
 	else
-		return (new ncmul(v))->setflag(status_flags::dynallocated |
-		                               status_flags::evaluated);
+		return dynallocate<ncmul>(v).setflag(status_flags::evaluated);
 }
 
 GINAC_BIND_UNARCHIVER(ncmul);