- added idx::replace_dim() and idx::minimal_dim()
authorChristian Bauer <Christian.Bauer@uni-mainz.de>
Mon, 15 Jul 2002 14:23:56 +0000 (14:23 +0000)
committerChristian Bauer <Christian.Bauer@uni-mainz.de>
Mon, 15 Jul 2002 14:23:56 +0000 (14:23 +0000)
- 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)

ginac/idx.cpp
ginac/idx.h

index a3767fe..6a9ac8a 100644 (file)
@@ -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());
index b648c62..0b31696 100644 (file)
@@ -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) */