added missing minimal_dim() from 1.1 branch

[ginac.git] / ginac / idx.cpp

diff --git a/ginac/idx.cpp b/ginac/idx.cpp
index 74754022e63f6f73996404d3e2ea389cd0d2fa5e..82052d88f45d36a17db90129682c5861779b586f 100644 (file)
--- a/ginac/idx.cpp
+++ b/ginac/idx.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's indices. */
 
 /*
- *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2003 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
@@ -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"
@@ -156,14 +157,18 @@ void idx::print(const print_context & c, unsigned level) const
 
        } else {
 
-               if (!is_of_type(c, print_latex))
+               if (is_a<print_latex>(c))
+                       c.s << "{";
+               else
                        c.s << ".";
-               bool need_parens = !(is_ex_exactly_of_type(value, numeric) || is_ex_of_type(value, symbol));
+               bool need_parens = !(is_exactly_a<numeric>(value) || is_a<symbol>(value));
                if (need_parens)
                        c.s << "(";
                value.print(c);
                if (need_parens)
                        c.s << ")";
+               if (is_a<print_latex>(c))
+                       c.s << "}";
        }
 }
 
@@ -180,19 +185,22 @@ void varidx::print(const print_context & c, unsigned level) const
                dim.print(c, level + delta_indent);
 
        } else {
-
-               if (!is_of_type(c, print_latex)) {
+               if (is_a<print_latex>(c))
+                       c.s << "{";
+               else {
                        if (covariant)
                                c.s << ".";
                        else
                                c.s << "~";
                }
-               bool need_parens = !(is_ex_exactly_of_type(value, numeric) || is_ex_of_type(value, symbol));
+               bool need_parens = !(is_exactly_a<numeric>(value) || is_a<symbol>(value));
                if (need_parens)
                        c.s << "(";
                value.print(c);
                if (need_parens)
                        c.s << ")";
+               if (is_a<print_latex>(c))
+                       c.s << "}";
        }
 }
 
@@ -212,7 +220,12 @@ void spinidx::print(const print_context & c, unsigned level) const
        } else {
 
                bool is_tex = is_of_type(c, print_latex);
-               if (!is_tex) {
+               if (is_tex) {
+                       if (covariant)
+                               c.s << "_{";
+                       else
+                               c.s << "^{";
+               } else {
                        if (covariant)
                                c.s << ".";
                        else
@@ -224,7 +237,7 @@ void spinidx::print(const print_context & c, unsigned level) const
                        else
                                c.s << "*";
                }
-               bool need_parens = !(is_ex_exactly_of_type(value, numeric) || is_ex_of_type(value, symbol));
+               bool need_parens = !(is_exactly_a<numeric>(value) || is_a<symbol>(value));
                if (need_parens)
                        c.s << "(";
                value.print(c);
@@ -232,6 +245,8 @@ void spinidx::print(const print_context & c, unsigned level) const
                        c.s << ")";
                if (is_tex && dotted)
                        c.s << "}";
+               if (is_tex)
+                       c.s << "}";
        }
 }
 
@@ -342,7 +357,7 @@ ex idx::subs(const lst & ls, const lst & lr, bool no_pattern) const
                if (is_equal(ex_to<basic>(ls.op(i)))) {
 
                        // Substitution index->index
-                       if (is_ex_of_type(lr.op(i), idx))
+                       if (is_a<idx>(lr.op(i)))
                                return lr.op(i);
 
                        // Otherwise substitute value
@@ -380,16 +395,21 @@ 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
-       if (!is_ex_of_type(value, symbol))
+       // Only pure symbols form dummy pairs, numeric indices and expressions
+       // like "2n+1" don't
+       if (!is_a<symbol>(value))
                return false;
 
        // Value must be equal, of course
        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 || (is_exactly_a<numeric>(dim) && is_a<symbol>(o.dim)) || (is_a<symbol>(dim) && is_exactly_a<numeric>(o.dim)));
 }
 
 bool varidx::is_dummy_pair_same_type(const basic & other) const
@@ -419,6 +439,19 @@ 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
+{
+       return GiNaC::minimal_dim(dim, other.dim);
+}
+
 ex varidx::toggle_variance(void) const
 {
        varidx *i_copy = static_cast<varidx *>(duplicate());
@@ -461,7 +494,7 @@ bool is_dummy_pair(const idx & i1, const idx & i2)
 bool is_dummy_pair(const ex & e1, const ex & e2)
 {
        // The expressions must be indices
-       if (!is_ex_of_type(e1, idx) || !is_ex_of_type(e2, idx))
+       if (!is_a<idx>(e1) || !is_a<idx>(e2))
                return false;
 
        return is_dummy_pair(ex_to<idx>(e1), ex_to<idx>(e2));
@@ -507,4 +540,14 @@ void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator i
                out_free.push_back(*last);
 }
 
+ex minimal_dim(const ex & dim1, const ex & dim2)
+{
+       if (dim1.is_equal(dim2) || dim1 < dim2 || (is_exactly_a<numeric>(dim1) && is_a<symbol>(dim2)))
+               return dim1;
+       else if (dim1 > dim2 || (is_a<symbol>(dim1) && is_exactly_a<numeric>(dim2)))
+               return dim2;
+       else
+               throw (std::runtime_error("minimal_dim(): index dimensions cannot be ordered"));
+}
+
 } // namespace GiNaC