X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Findexed.cpp;h=0c4103c2ef6e30b2d5be617185c17814c5c1e02e;hp=c8b710ae7f1e63690cbb0356e2e1ccc10159f1e0;hb=a1232ef3c23d3af7673c96ec4f0e0c652054564a;hpb=83a7ee99a947cbbf331018b803ad6be43a9ccd45

diff --git a/ginac/indexed.cpp b/ginac/indexed.cpp
index c8b710ae..0c4103c2 100644
--- a/ginac/indexed.cpp
+++ b/ginac/indexed.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's indexed expressions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2014 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
@@ -20,11 +20,6 @@
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include <iostream>
-#include <sstream>
-#include <stdexcept>
-#include <limits>
-
 #include "indexed.h"
 #include "idx.h"
 #include "add.h"
@@ -42,6 +37,11 @@
 #include "matrix.h"
 #include "inifcns.h"
 
+#include <iostream>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+
 namespace GiNaC {
 
 GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(indexed, exprseq,
@@ -55,7 +55,6 @@ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(indexed, exprseq,
 
 indexed::indexed() : symtree(not_symmetric())
 {
-	tinfo_key = &indexed::tinfo_static;
 }
 
 //////////
@@ -64,87 +63,75 @@ indexed::indexed() : symtree(not_symmetric())
 
 indexed::indexed(const ex & b) : inherited(b), symtree(not_symmetric())
 {
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const ex & i1) : inherited(b, i1), symtree(not_symmetric())
 {
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const ex & i1, const ex & i2) : inherited(b, i1, i2), symtree(not_symmetric())
 {
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const ex & i1, const ex & i2, const ex & i3) : inherited(b, i1, i2, i3), symtree(not_symmetric())
 {
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const ex & i1, const ex & i2, const ex & i3, const ex & i4) : inherited(b, i1, i2, i3, i4), symtree(not_symmetric())
 {
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const symmetry & symm, const ex & i1, const ex & i2) : inherited(b, i1, i2), symtree(symm)
 {
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const symmetry & symm, const ex & i1, const ex & i2, const ex & i3) : inherited(b, i1, i2, i3), symtree(symm)
 {
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const symmetry & symm, const ex & i1, const ex & i2, const ex & i3, const ex & i4) : inherited(b, i1, i2, i3, i4), symtree(symm)
 {
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const exvector & v) : inherited(b), symtree(not_symmetric())
 {
 	seq.insert(seq.end(), v.begin(), v.end());
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const ex & b, const symmetry & symm, const exvector & v) : inherited(b), symtree(symm)
 {
 	seq.insert(seq.end(), v.begin(), v.end());
-	tinfo_key = &indexed::tinfo_static;
 	validate();
 }
 
 indexed::indexed(const symmetry & symm, const exprseq & es) : inherited(es), symtree(symm)
 {
-	tinfo_key = &indexed::tinfo_static;
 }
 
 indexed::indexed(const symmetry & symm, const exvector & v, bool discardable) : inherited(v, discardable), symtree(symm)
 {
-	tinfo_key = &indexed::tinfo_static;
 }
 
 indexed::indexed(const symmetry & symm, std::auto_ptr<exvector> vp) : inherited(vp), symtree(symm)
 {
-	tinfo_key = &indexed::tinfo_static;
 }
 
 //////////
 // archiving
 //////////
 
-indexed::indexed(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
+void indexed::read_archive(const archive_node &n, lst &sym_lst)
 {
+	inherited::read_archive(n, sym_lst);
 	if (!n.find_ex("symmetry", symtree, sym_lst)) {
 		// GiNaC versions <= 0.9.0 had an unsigned "symmetry" property
 		unsigned symm = 0;
@@ -163,6 +150,7 @@ indexed::indexed(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
 		const_cast<symmetry &>(ex_to<symmetry>(symtree)).validate(seq.size() - 1);
 	}
 }
+GINAC_BIND_UNARCHIVER(indexed);
 
 void indexed::archive(archive_node &n) const
 {
@@ -170,8 +158,6 @@ void indexed::archive(archive_node &n) const
 	n.add_ex("symmetry", symtree);
 }
 
-DEFAULT_UNARCHIVE(indexed)
-
 //////////
 // functions overriding virtual functions from base classes
 //////////
@@ -299,7 +285,7 @@ ex indexed::eval(int level) const
 		return f * thiscontainer(v);
 	}
 
-	if(this->tinfo()==&indexed::tinfo_static && seq.size()==1)
+	if((typeid(*this) == typeid(indexed)) && seq.size()==1)
 		return base;
 
 	// Canonicalize indices according to the symmetry properties
@@ -811,6 +797,7 @@ ex simplify_indexed_product(const ex & e, exvector & free_indices, exvector & du
 
 	// Perform contractions
 	bool something_changed = false;
+	bool has_nonsymmetric = false;
 	GINAC_ASSERT(v.size() > 1);
 	exvector::iterator it1, itend = v.end(), next_to_last = itend - 1;
 	for (it1 = v.begin(); it1 != next_to_last; it1++) {
@@ -820,6 +807,7 @@ try_again:
 			continue;
 
 		bool first_noncommutative = (it1->return_type() != return_types::commutative);
+		bool first_nonsymmetric = ex_to<symmetry>(ex_to<indexed>(*it1).get_symmetry()).has_nonsymmetric();
 
 		// Indexed factor found, get free indices and look for contraction
 		// candidates
@@ -886,8 +874,16 @@ contraction_done:
 					// Non-commutative products are always re-expanded to give
 					// eval_ncmul() the chance to re-order and canonicalize
 					// the product
+					bool is_a_product = (is_exactly_a<mul>(*it1) || is_exactly_a<ncmul>(*it1)) &&
+					                    (is_exactly_a<mul>(*it2) || is_exactly_a<ncmul>(*it2));
 					ex r = (non_commutative ? ex(ncmul(v, true)) : ex(mul(v)));
-					return simplify_indexed(r, free_indices, dummy_indices, sp);
+
+					// If new expression is a product we can call this function again,
+					// otherwise we need to pass argument to simplify_indexed() to be expanded
+					if (is_a_product)
+						return simplify_indexed_product(r, free_indices, dummy_indices, sp);
+					else
+						return simplify_indexed(r, free_indices, dummy_indices, sp);
 				}
 
 				// Both objects may have new indices now or they might
@@ -896,6 +892,11 @@ contraction_done:
 				something_changed = true;
 				goto try_again;
 			}
+			else if (!has_nonsymmetric &&
+					(first_nonsymmetric ||
+					 ex_to<symmetry>(ex_to<indexed>(*it2).get_symmetry()).has_nonsymmetric())) {
+				has_nonsymmetric = true;
+			}
 		}
 	}
 
@@ -949,20 +950,22 @@ contraction_done:
 	// The result should be symmetric with respect to exchange of dummy
 	// indices, so if the symmetrization vanishes, the whole expression is
 	// zero. This detects things like eps.i.j.k * p.j * p.k = 0.
-	ex q = idx_symmetrization<idx>(r, local_dummy_indices);
-	if (q.is_zero()) {
-		free_indices.clear();
-		return _ex0;
-	}
-	q = idx_symmetrization<varidx>(q, local_dummy_indices);
-	if (q.is_zero()) {
-		free_indices.clear();
-		return _ex0;
-	}
-	q = idx_symmetrization<spinidx>(q, local_dummy_indices);
-	if (q.is_zero()) {
-		free_indices.clear();
-		return _ex0;
+	if (has_nonsymmetric) {
+		ex q = idx_symmetrization<idx>(r, local_dummy_indices);
+		if (q.is_zero()) {
+			free_indices.clear();
+			return _ex0;
+		}
+		q = idx_symmetrization<varidx>(q, local_dummy_indices);
+		if (q.is_zero()) {
+			free_indices.clear();
+			return _ex0;
+		}
+		q = idx_symmetrization<spinidx>(q, local_dummy_indices);
+		if (q.is_zero()) {
+			free_indices.clear();
+			return _ex0;
+		}
 	}
 
 	// Dummy index renaming
@@ -1409,7 +1412,7 @@ exvector get_all_dummy_indices_safely(const ex & e)
 	else if (is_a<mul>(e) || is_a<ncmul>(e)) {
 		exvector dummies;
 		exvector free_indices;
-		for (int i=0; i<e.nops(); ++i) {
+		for (std::size_t i = 0; i < e.nops(); ++i) {
 			exvector dummies_of_factor = get_all_dummy_indices_safely(e.op(i));
 			dummies.insert(dummies.end(), dummies_of_factor.begin(),
 				dummies_of_factor.end());
@@ -1425,7 +1428,7 @@ exvector get_all_dummy_indices_safely(const ex & e)
 	}
 	else if(is_a<add>(e)) {
 		exvector result;
-		for(int i=0; i<e.nops(); ++i) {
+		for(std::size_t i = 0; i < e.nops(); ++i) {
 			exvector dummies_of_term = get_all_dummy_indices_safely(e.op(i));
 			sort(dummies_of_term.begin(), dummies_of_term.end());
 			exvector new_vec;