metric tensors now silently replace their indices' dimensions with their
[ginac.git] / ginac / tensor.cpp
index 7ab2ef91cde6f0472b680426eca8fcfa616adde2..0c36a68002423d712f4d8afa5ec903716ffba7e7 100644 (file)
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's special tensors. */
 
 /*
  *  Implementation of GiNaC's special tensors. */
 
 /*
- *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2002 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
  *
  *  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,6 +20,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <iostream>
 #include <stdexcept>
 #include <vector>
 
 #include <stdexcept>
 #include <vector>
 
@@ -178,9 +179,14 @@ ex tensdelta::eval_indexed(const basic & i) const
        const idx & i1 = ex_to<idx>(i.op(1));
        const idx & i2 = ex_to<idx>(i.op(2));
 
        const idx & i1 = ex_to<idx>(i.op(1));
        const idx & i2 = ex_to<idx>(i.op(2));
 
-       // Trace of delta tensor is the dimension of the space
-       if (is_dummy_pair(i1, i2))
-               return i1.get_dim();
+       // Trace of delta tensor is the (effective) dimension of the space
+       if (is_dummy_pair(i1, i2)) {
+               try {
+                       return i1.minimal_dim(i2);
+               } catch (std::exception &e) {
+                       return i.hold();
+               }
+       }
 
        // Numeric evaluation
        if (static_cast<const indexed &>(i).all_index_values_are(info_flags::integer)) {
 
        // Numeric evaluation
        if (static_cast<const indexed &>(i).all_index_values_are(info_flags::integer)) {
@@ -207,6 +213,13 @@ ex tensmetric::eval_indexed(const basic & i) const
        const varidx & i1 = ex_to<varidx>(i.op(1));
        const varidx & i2 = ex_to<varidx>(i.op(2));
 
        const varidx & i1 = ex_to<varidx>(i.op(1));
        const varidx & i2 = ex_to<varidx>(i.op(2));
 
+       // The dimension of the indices must be equal, otherwise we use the minimal
+       // dimension
+       if (!i1.get_dim().is_equal(i2.get_dim())) {
+               ex min_dim = i1.minimal_dim(i2);
+               return i.subs(lst(i1 == i1.replace_dim(min_dim), i2 == i2.replace_dim(min_dim)));
+       }
+
        // A metric tensor with one covariant and one contravariant index gets
        // replaced by a delta tensor
        if (i1.is_covariant() != i2.is_covariant())
        // A metric tensor with one covariant and one contravariant index gets
        // replaced by a delta tensor
        if (i1.is_covariant() != i2.is_covariant())
@@ -317,15 +330,9 @@ ex tensepsilon::eval_indexed(const basic & i) const
        return i.hold();
 }
 
        return i.hold();
 }
 
-/** Contraction of an indexed delta tensor with something else. */
-bool tensdelta::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const
+bool tensor::replace_contr_index(exvector::iterator self, exvector::iterator other) const
 {
 {
-       GINAC_ASSERT(is_a<indexed>(*self));
-       GINAC_ASSERT(is_a<indexed>(*other));
-       GINAC_ASSERT(self->nops() == 3);
-       GINAC_ASSERT(is_a<tensdelta>(self->op(0)));
-
-       // Try to contract first index
+       // Try to contract the first index
        const idx *self_idx = &ex_to<idx>(self->op(1));
        const idx *free_idx = &ex_to<idx>(self->op(2));
        bool first_index_tried = false;
        const idx *self_idx = &ex_to<idx>(self->op(1));
        const idx *free_idx = &ex_to<idx>(self->op(2));
        bool first_index_tried = false;
@@ -336,18 +343,24 @@ again:
                        const idx &other_idx = ex_to<idx>(other->op(i));
                        if (is_dummy_pair(*self_idx, other_idx)) {
 
                        const idx &other_idx = ex_to<idx>(other->op(i));
                        if (is_dummy_pair(*self_idx, other_idx)) {
 
-                               // Contraction found, remove delta tensor and substitute
-                               // index in second object
-                               *self = _ex1;
-                               *other = other->subs(other_idx == *free_idx);
-                               return true;
+                               // Contraction found, remove this tensor and substitute the
+                               // index in the second object
+                               try {
+                                       // minimal_dim() throws an exception when index dimensions are not comparable
+                                       ex min_dim = self_idx->minimal_dim(other_idx);
+                                       *self = _ex1;
+                                       *other = other->subs(other_idx == free_idx->replace_dim(min_dim));
+                                       return true;
+                               } catch (std::exception &e) {
+                                       return false;
+                               }
                        }
                }
        }
 
        if (!first_index_tried) {
 
                        }
                }
        }
 
        if (!first_index_tried) {
 
-               // No contraction with first index found, try second index
+               // No contraction with the first index found, try the second index
                self_idx = &ex_to<idx>(self->op(2));
                free_idx = &ex_to<idx>(self->op(1));
                first_index_tried = true;
                self_idx = &ex_to<idx>(self->op(2));
                free_idx = &ex_to<idx>(self->op(1));
                first_index_tried = true;
@@ -357,6 +370,19 @@ again:
        return false;
 }
 
        return false;
 }
 
+/** Contraction of an indexed delta tensor with something else. */
+bool tensdelta::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const
+{
+       GINAC_ASSERT(is_a<indexed>(*self));
+       GINAC_ASSERT(is_a<indexed>(*other));
+       GINAC_ASSERT(self->nops() == 3);
+       GINAC_ASSERT(is_a<tensdelta>(self->op(0)));
+
+       // Replace the dummy index with this tensor's other index and remove
+       // the tensor (this is valid for contractions with all other tensors)
+       return replace_contr_index(self, other);
+}
+
 /** Contraction of an indexed metric tensor with something else. */
 bool tensmetric::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const
 {
 /** Contraction of an indexed metric tensor with something else. */
 bool tensmetric::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const
 {
@@ -370,36 +396,9 @@ bool tensmetric::contract_with(exvector::iterator self, exvector::iterator other
        if (is_ex_of_type(other->op(0), tensdelta))
                return false;
 
        if (is_ex_of_type(other->op(0), tensdelta))
                return false;
 
-       // Try to contract first index
-       const idx *self_idx = &ex_to<idx>(self->op(1));
-       const idx *free_idx = &ex_to<idx>(self->op(2));
-       bool first_index_tried = false;
-
-again:
-       if (self_idx->is_symbolic()) {
-               for (unsigned i=1; i<other->nops(); i++) {
-                       const idx &other_idx = ex_to<idx>(other->op(i));
-                       if (is_dummy_pair(*self_idx, other_idx)) {
-
-                               // Contraction found, remove metric tensor and substitute
-                               // index in second object
-                               *self = _ex1;
-                               *other = other->subs(other_idx == *free_idx);
-                               return true;
-                       }
-               }
-       }
-
-       if (!first_index_tried) {
-
-               // No contraction with first index found, try second index
-               self_idx = &ex_to<idx>(self->op(2));
-               free_idx = &ex_to<idx>(self->op(1));
-               first_index_tried = true;
-               goto again;
-       }
-
-       return false;
+       // Replace the dummy index with this tensor's other index and remove
+       // the tensor (this is valid for contractions with all other tensors)
+       return replace_contr_index(self, other);
 }
 
 /** Contraction of an indexed spinor metric with something else. */
 }
 
 /** Contraction of an indexed spinor metric with something else. */
@@ -506,44 +505,6 @@ bool tensepsilon::contract_with(exvector::iterator self, exvector::iterator othe
                *self = sign * M.determinant().simplify_indexed();
                *other = _ex1;
                return true;
                *self = sign * M.determinant().simplify_indexed();
                *other = _ex1;
                return true;
-
-       } else if (other->return_type() == return_types::commutative) {
-
-#if 0
-               // This handles eps.i.j.k * p.j * p.k = 0
-               // Maybe something like this should go to simplify_indexed() because
-               // such relations are true for any antisymmetric tensors...
-               exvector c;
-
-               // Handle all indices of the epsilon tensor
-               for (int i=0; i<num; i++) {
-                       ex idx = self->op(i+1);
-
-                       // Look whether there's a contraction with this index
-                       exvector::const_iterator ait, aitend = v.end();
-                       for (ait = v.begin(); ait != aitend; ait++) {
-                               if (ait == self)
-                                       continue;
-                               if (is_a<indexed>(*ait) && ait->return_type() == return_types::commutative && ex_to<indexed>(*ait).has_dummy_index_for(idx) && ait->nops() == 2) {
-
-                                       // Yes, did we already have another contraction with the same base expression?
-                                       ex base = ait->op(0);
-                                       if (std::find_if(c.begin(), c.end(), bind2nd(ex_is_equal(), base)) == c.end()) {
-
-                                               // No, add the base expression to the list
-                                               c.push_back(base);
-
-                                       } else {
-
-                                               // Yes, the contraction is zero
-                                               *self = _ex0;
-                                               *other = _ex0;
-                                               return true;
-                                       }
-                               }
-                       }
-               }
-#endif
        }
 
        return false;
        }
 
        return false;
@@ -629,16 +590,4 @@ ex lorentz_eps(const ex & i1, const ex & i2, const ex & i3, const ex & i4, bool
        return indexed(tensepsilon(true, pos_sig), sy_anti(), i1, i2, i3, i4);
 }
 
        return indexed(tensepsilon(true, pos_sig), sy_anti(), i1, i2, i3, i4);
 }
 
-ex eps0123(const ex & i1, const ex & i2, const ex & i3, const ex & i4, bool pos_sig)
-{
-       if (!is_ex_of_type(i1, varidx) || !is_ex_of_type(i2, varidx) || !is_ex_of_type(i3, varidx) || !is_ex_of_type(i4, varidx))
-               throw(std::invalid_argument("indices of epsilon tensor must be of type varidx"));
-
-       ex dim = ex_to<idx>(i1).get_dim();
-       if (dim.is_equal(4))
-               return lorentz_eps(i1, i2, i3, i4, pos_sig);
-       else
-               return indexed(tensepsilon(true, pos_sig), sy_anti(), i1, i2, i3, i4);
-}
-
 } // namespace GiNaC
 } // namespace GiNaC