- added idx::replace_dim() and idx::minimal_dim()

- indices no longer need to be of the same dimension to be recognized as
  dummy indices, but they must be comparable (to determine their minimum)
(Nein, Markus, das ist noch nicht das mit den vierdimensionalen Tensoren)

diff --git a/ginac/idx.cpp b/ginac/idx.cpp
index a3767fe8c5c65e7dc357e712cf79b34756737347..6a9ac8ae3ad33250c10e8a2a2dcc04ce8c1b9d47 100644 (file)
--- a/ginac/idx.cpp
+++ b/ginac/idx.cpp
@@ -26,6 +26,7 @@
 #include "idx.h"
 #include "symbol.h"
 #include "lst.h"
+#include "relational.h"
 #include "print.h"
 #include "archive.h"
 #include "utils.h"
@@ -394,7 +395,8 @@ bool idx::is_dummy_pair_same_type(const basic & other) const
 {
        const idx &o = static_cast<const idx &>(other);
 
-       // Only pure symbols form dummy pairs, "2n+1" doesn't
+       // Only pure symbols form dummy pairs, numeric indices and expressions
+       // like "2n+1" don't
        if (!is_ex_of_type(value, symbol))
                return false;
 
@@ -402,8 +404,12 @@ bool idx::is_dummy_pair_same_type(const basic & other) const
        if (!value.is_equal(o.value))
                return false;
 
-       // Also the dimension
-       return dim.is_equal(o.dim);
+       // Dimensions need not be equal but must be comparable (so we can
+       // determine the minimum dimension of contractions)
+       if (dim.is_equal(o.dim))
+               return true;
+
+       return (dim < o.dim || dim > o.dim);
 }
 
 bool varidx::is_dummy_pair_same_type(const basic & other) const
@@ -433,6 +439,24 @@ bool spinidx::is_dummy_pair_same_type(const basic & other) const
 // non-virtual functions
 //////////
 
+ex idx::replace_dim(const ex & new_dim) const
+{
+       idx *i_copy = static_cast<idx *>(duplicate());
+       i_copy->dim = new_dim;
+       i_copy->clearflag(status_flags::hash_calculated);
+       return i_copy->setflag(status_flags::dynallocated);
+}
+
+ex idx::minimal_dim(const idx & other) const
+{
+       if (dim.is_equal(other.dim) || dim < other.dim)
+               return dim;
+       else if (dim > other.dim)
+               return other.dim;
+       else
+               throw (std::runtime_error("idx::minimal_dim: index dimensions cannot be ordered"));
+}
+
 ex varidx::toggle_variance(void) const
 {
        varidx *i_copy = static_cast<varidx *>(duplicate());

diff --git a/ginac/idx.h b/ginac/idx.h
index b648c62ac74357466244639940dbfd87fcd7a942..0b31696c772840c347aa0fad1aa9e71099de93c7 100644 (file)
--- a/ginac/idx.h
+++ b/ginac/idx.h
@@ -85,6 +85,13 @@ public:
        /** Check whether the dimension is symbolic. */
        bool is_dim_symbolic(void) const {return !is_exactly_a<numeric>(dim);}
 
+       /** Make a new index with the same value but a different dimension. */
+       ex replace_dim(const ex & new_dim) const;
+
+       /** Return the minimum of the dimensions of this and another index.
+        *  If this is undecidable, throw an exception. */
+       ex minimal_dim(const idx & other) const;
+
 protected:
        ex value; /**< Expression that constitutes the index (numeric or symbolic name) */
        ex dim;   /**< Dimension of space (can be symbolic or numeric) */