Add support for Texinfo-5.0.
[ginac.git] / ginac / idx.cpp
index e2b76be..a3f0b84 100644 (file)
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's indices. */
 
 /*
- *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2011 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
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include <stdexcept>
-#include <algorithm>
-
 #include "idx.h"
 #include "symbol.h"
 #include "lst.h"
-#include "print.h"
+#include "relational.h"
+#include "operators.h"
 #include "archive.h"
 #include "utils.h"
-#include "debugmsg.h"
+#include "hash_seed.h"
+
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
 
 namespace GiNaC {
 
-GINAC_IMPLEMENT_REGISTERED_CLASS(idx, basic)
-GINAC_IMPLEMENT_REGISTERED_CLASS(varidx, idx)
-GINAC_IMPLEMENT_REGISTERED_CLASS(spinidx, varidx)
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(idx, basic,
+  print_func<print_context>(&idx::do_print).
+  print_func<print_latex>(&idx::do_print_latex).
+  print_func<print_csrc>(&idx::do_print_csrc).
+  print_func<print_tree>(&idx::do_print_tree))
+
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(varidx, idx,
+  print_func<print_context>(&varidx::do_print).
+  print_func<print_latex>(&varidx::do_print_latex).
+  print_func<print_tree>(&varidx::do_print_tree))
+
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(spinidx, varidx,
+  print_func<print_context>(&spinidx::do_print).
+  print_func<print_latex>(&spinidx::do_print_latex).
+  print_func<print_tree>(&spinidx::do_print_tree))
 
 //////////
-// default constructor, destructor, copy constructor assignment operator and helpers
+// default constructor
 //////////
 
-idx::idx() : inherited(TINFO_idx)
-{
-       debugmsg("idx default constructor", LOGLEVEL_CONSTRUCT);
-}
+idx::idx() {}
 
 varidx::varidx() : covariant(false)
 {
-       debugmsg("varidx default constructor", LOGLEVEL_CONSTRUCT);
-       tinfo_key = TINFO_varidx;
 }
 
 spinidx::spinidx() : dotted(false)
 {
-       debugmsg("spinidx default constructor", LOGLEVEL_CONSTRUCT);
-       tinfo_key = TINFO_spinidx;
-}
-
-void idx::copy(const idx & other)
-{
-       inherited::copy(other);
-       value = other.value;
-       dim = other.dim;
-}
-
-void varidx::copy(const varidx & other)
-{
-       inherited::copy(other);
-       covariant = other.covariant;
-}
-
-void spinidx::copy(const spinidx & other)
-{
-       inherited::copy(other);
-       dotted = other.dotted;
 }
 
-DEFAULT_DESTROY(idx)
-DEFAULT_DESTROY(varidx)
-DEFAULT_DESTROY(spinidx)
-
 //////////
 // other constructors
 //////////
 
-idx::idx(const ex & v, const ex & d) : inherited(TINFO_idx), value(v), dim(d)
+idx::idx(const ex & v, const ex & d) :  value(v), dim(d)
 {
-       debugmsg("idx constructor from ex,ex", LOGLEVEL_CONSTRUCT);
        if (is_dim_numeric())
                if (!dim.info(info_flags::posint))
                        throw(std::invalid_argument("dimension of space must be a positive integer"));
@@ -95,38 +78,37 @@ idx::idx(const ex & v, const ex & d) : inherited(TINFO_idx), value(v), dim(d)
 
 varidx::varidx(const ex & v, const ex & d, bool cov) : inherited(v, d), covariant(cov)
 {
-       debugmsg("varidx constructor from ex,ex,bool", LOGLEVEL_CONSTRUCT);
-       tinfo_key = TINFO_varidx;
 }
 
 spinidx::spinidx(const ex & v, const ex & d, bool cov, bool dot) : inherited(v, d, cov), dotted(dot)
 {
-       debugmsg("spinidx constructor from ex,ex,bool,bool", LOGLEVEL_CONSTRUCT);
-       tinfo_key = TINFO_spinidx;
 }
 
 //////////
 // archiving
 //////////
 
-idx::idx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
+void idx::read_archive(const archive_node& n, lst& sym_lst) 
 {
-       debugmsg("idx constructor from archive_node", LOGLEVEL_CONSTRUCT);
+       inherited::read_archive(n, sym_lst);
        n.find_ex("value", value, sym_lst);
        n.find_ex("dim", dim, sym_lst);
 }
+GINAC_BIND_UNARCHIVER(idx);
 
-varidx::varidx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
+void varidx::read_archive(const archive_node& n, lst& sym_lst)
 {
-       debugmsg("varidx constructor from archive_node", LOGLEVEL_CONSTRUCT);
+       inherited::read_archive(n, sym_lst);
        n.find_bool("covariant", covariant);
 }
+GINAC_BIND_UNARCHIVER(varidx);
 
-spinidx::spinidx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
+void spinidx::read_archive(const archive_node& n, lst& sym_lst)
 {
-       debugmsg("spinidx constructor from archive_node", LOGLEVEL_CONSTRUCT);
+       inherited::read_archive(n, sym_lst);
        n.find_bool("dotted", dotted);
 }
+GINAC_BIND_UNARCHIVER(spinidx);
 
 void idx::archive(archive_node &n) const
 {
@@ -147,136 +129,149 @@ void spinidx::archive(archive_node &n) const
        n.add_bool("dotted", dotted);
 }
 
-DEFAULT_UNARCHIVE(idx)
-DEFAULT_UNARCHIVE(varidx)
-DEFAULT_UNARCHIVE(spinidx)
-
 //////////
-// functions overriding virtual functions from bases classes
+// functions overriding virtual functions from base classes
 //////////
 
-void idx::print(const print_context & c, unsigned level) const
-{
-       debugmsg("idx print", LOGLEVEL_PRINT);
-
-       if (is_of_type(c, print_tree)) {
-
-               c.s << std::string(level, ' ') << class_name()
-                   << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
-                   << std::endl;
-               unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
-               value.print(c, level + delta_indent);
-               dim.print(c, level + delta_indent);
-
-       } else {
-
-               if (!is_of_type(c, print_latex))
-                       c.s << ".";
-               bool need_parens = !(is_ex_exactly_of_type(value, numeric) || is_ex_of_type(value, symbol));
-               if (need_parens)
-                       c.s << "(";
-               value.print(c);
-               if (need_parens)
-                       c.s << ")";
+void idx::print_index(const print_context & c, unsigned level) const
+{
+       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 (c.options & print_options::print_index_dimensions) {
+               c.s << "[";
+               dim.print(c);
+               c.s << "]";
        }
 }
 
-void varidx::print(const print_context & c, unsigned level) const
+void idx::do_print(const print_context & c, unsigned level) const
 {
-       debugmsg("varidx print", LOGLEVEL_PRINT);
-
-       if (is_of_type(c, print_tree)) {
-
-               c.s << std::string(level, ' ') << class_name()
-                   << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
-                   << (covariant ? ", covariant" : ", contravariant")
-                   << std::endl;
-               unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
-               value.print(c, level + delta_indent);
-               dim.print(c, level + delta_indent);
+       c.s << ".";
+       print_index(c, level);
+}
 
-       } else {
+void idx::do_print_latex(const print_latex & c, unsigned level) const
+{
+       c.s << "{";
+       print_index(c, level);
+       c.s << "}";
+}
 
-               if (!is_of_type(c, print_latex)) {
-                       if (covariant)
-                               c.s << ".";
-                       else
-                               c.s << "~";
-               }
-               bool need_parens = !(is_ex_exactly_of_type(value, numeric) || is_ex_of_type(value, symbol));
-               if (need_parens)
-                       c.s << "(";
+void idx::do_print_csrc(const print_csrc & c, unsigned level) const
+{
+       c.s << "[";
+       if (value.info(info_flags::integer))
+               c.s << ex_to<numeric>(value).to_int();
+       else
                value.print(c);
-               if (need_parens)
-                       c.s << ")";
-       }
+       c.s << "]";
 }
 
-void spinidx::print(const print_context & c, unsigned level) const
+void idx::do_print_tree(const print_tree & c, unsigned level) const
 {
-       debugmsg("spinidx print", LOGLEVEL_PRINT);
+       c.s << std::string(level, ' ') << class_name() << " @" << this
+           << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
+           << std::endl;
+       value.print(c, level +  c.delta_indent);
+       dim.print(c, level + c.delta_indent);
+}
+
+void varidx::do_print(const print_context & c, unsigned level) const
+{
+       if (covariant)
+               c.s << ".";
+       else
+               c.s << "~";
+       print_index(c, level);
+}
 
-       if (is_of_type(c, print_tree)) {
+void varidx::do_print_tree(const print_tree & c, unsigned level) const
+{
+       c.s << std::string(level, ' ') << class_name() << " @" << this
+           << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
+           << (covariant ? ", covariant" : ", contravariant")
+           << std::endl;
+       value.print(c, level + c.delta_indent);
+       dim.print(c, level + c.delta_indent);
+}
 
-               c.s << std::string(level, ' ') << class_name()
-                   << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
-                   << (covariant ? ", covariant" : ", contravariant")
-                   << (dotted ? ", dotted" : ", undotted")
-                   << std::endl;
-               unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
-               value.print(c, level + delta_indent);
-               dim.print(c, level + delta_indent);
+void spinidx::do_print(const print_context & c, unsigned level) const
+{
+       if (covariant)
+               c.s << ".";
+       else
+               c.s << "~";
+       if (dotted)
+               c.s << "*";
+       print_index(c, level);
+}
 
-       } else {
+void spinidx::do_print_latex(const print_latex & c, unsigned level) const
+{
+       if (dotted)
+               c.s << "\\dot{";
+       else
+               c.s << "{";
+       print_index(c, level);
+       c.s << "}";
+}
 
-               bool is_tex = is_of_type(c, print_latex);
-               if (!is_tex) {
-                       if (covariant)
-                               c.s << ".";
-                       else
-                               c.s << "~";
-               }
-               if (dotted) {
-                       if (is_tex)
-                               c.s << "\\dot{";
-                       else
-                               c.s << "*";
-               }
-               bool need_parens = !(is_ex_exactly_of_type(value, numeric) || is_ex_of_type(value, symbol));
-               if (need_parens)
-                       c.s << "(";
-               value.print(c);
-               if (need_parens)
-                       c.s << ")";
-               if (is_tex && dotted)
-                       c.s << "}";
-       }
+void spinidx::do_print_tree(const print_tree & c, unsigned level) const
+{
+       c.s << std::string(level, ' ') << class_name() << " @" << this
+           << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
+           << (covariant ? ", covariant" : ", contravariant")
+           << (dotted ? ", dotted" : ", undotted")
+           << std::endl;
+       value.print(c, level + c.delta_indent);
+       dim.print(c, level + c.delta_indent);
 }
 
 bool idx::info(unsigned inf) const
 {
-       if (inf == info_flags::idx)
-               return true;
+       switch(inf) {
+               case info_flags::idx:
+               case info_flags::has_indices:
+                       return true;
+       }
        return inherited::info(inf);
 }
 
-unsigned idx::nops() const
+size_t idx::nops() const
 {
        // don't count the dimension as that is not really a sub-expression
        return 1;
 }
 
-ex & idx::let_op(int i)
+ex idx::op(size_t i) const
 {
        GINAC_ASSERT(i == 0);
        return value;
 }
 
+ex idx::map(map_function & f) const
+{
+       const ex &mapped_value = f(value);
+       if (are_ex_trivially_equal(value, mapped_value))
+               return *this;
+       else {
+               idx *copy = duplicate();
+               copy->setflag(status_flags::dynallocated);
+               copy->clearflag(status_flags::hash_calculated);
+               copy->value = mapped_value;
+               return *copy;
+       }
+}
+
 /** Returns order relation between two indices of the same type. The order
  *  must be such that dummy indices lie next to each other. */
 int idx::compare_same_type(const basic & other) const
 {
-       GINAC_ASSERT(is_of_type(other, idx));
+       GINAC_ASSERT(is_a<idx>(other));
        const idx &o = static_cast<const idx &>(other);
 
        int cmpval = value.compare(o.value);
@@ -285,9 +280,17 @@ int idx::compare_same_type(const basic & other) const
        return dim.compare(o.dim);
 }
 
+bool idx::match_same_type(const basic & other) const
+{
+       GINAC_ASSERT(is_a<idx>(other));
+       const idx &o = static_cast<const idx &>(other);
+
+       return dim.is_equal(o.dim);
+}
+
 int varidx::compare_same_type(const basic & other) const
 {
-       GINAC_ASSERT(is_of_type(other, varidx));
+       GINAC_ASSERT(is_a<varidx>(other));
        const varidx &o = static_cast<const varidx &>(other);
 
        int cmpval = inherited::compare_same_type(other);
@@ -297,12 +300,24 @@ int varidx::compare_same_type(const basic & other) const
        // Check variance last so dummy indices will end up next to each other
        if (covariant != o.covariant)
                return covariant ? -1 : 1;
+
        return 0;
 }
 
+bool varidx::match_same_type(const basic & other) const
+{
+       GINAC_ASSERT(is_a<varidx>(other));
+       const varidx &o = static_cast<const varidx &>(other);
+
+       if (covariant != o.covariant)
+               return false;
+
+       return inherited::match_same_type(other);
+}
+
 int spinidx::compare_same_type(const basic & other) const
 {
-       GINAC_ASSERT(is_of_type(other, spinidx));
+       GINAC_ASSERT(is_a<spinidx>(other));
        const spinidx &o = static_cast<const spinidx &>(other);
 
        // Check dottedness first so dummy indices will end up next to each other
@@ -316,67 +331,82 @@ int spinidx::compare_same_type(const basic & other) const
        return 0;
 }
 
-bool idx::match(const ex & pattern, lst & repl_lst) const
+bool spinidx::match_same_type(const basic & other) const
 {
-       if (!is_ex_of_type(pattern, idx))
-               return false;
-       const idx &o = ex_to_idx(pattern);
-       if (!dim.is_equal(o.dim))
-               return false;
-       return value.match(o.value, repl_lst);
-}
+       GINAC_ASSERT(is_a<spinidx>(other));
+       const spinidx &o = static_cast<const spinidx &>(other);
 
-bool varidx::match(const ex & pattern, lst & repl_lst) const
-{
-       if (!is_ex_of_type(pattern, varidx))
-               return false;
-       const varidx &o = ex_to_varidx(pattern);
-       if (covariant != o.covariant)
+       if (dotted != o.dotted)
                return false;
-       return inherited::match(pattern, repl_lst);
+       return inherited::match_same_type(other);
+}
+
+unsigned idx::calchash() const
+{
+       // NOTE: The code in simplify_indexed() assumes that canonically
+       // ordered sequences of indices have the two members of dummy index
+       // pairs lying next to each other. The hash values for indices must
+       // be devised accordingly. The easiest (only?) way to guarantee the
+       // desired ordering is to make indices with the same value have equal
+       // hash keys. That is, the hash values must not depend on the index
+       // dimensions or other attributes (variance etc.).
+       // The compare_same_type() methods will take care of the rest.
+       unsigned v = make_hash_seed(typeid(*this));
+       v = rotate_left(v);
+       v ^= value.gethash();
+
+       // Store calculated hash value only if object is already evaluated
+       if (flags & status_flags::evaluated) {
+               setflag(status_flags::hash_calculated);
+               hashvalue = v;
+       }
+
+       return v;
 }
 
-bool spinidx::match(const ex & pattern, lst & repl_lst) const
+/** By default, basic::evalf would evaluate the index value but we don't want
+ *  a.1 to become a.(1.0). */
+ex idx::evalf(int level) const
 {
-       if (!is_ex_of_type(pattern, spinidx))
-               return false;
-       const spinidx &o = ex_to_spinidx(pattern);
-       if (dotted != o.dotted)
-               return false;
-       return inherited::match(pattern, repl_lst);
+       return *this;
 }
 
-ex idx::subs(const lst & ls, const lst & lr, bool no_pattern) const
+ex idx::subs(const exmap & m, unsigned options) const
 {
-       GINAC_ASSERT(ls.nops() == lr.nops());
-
        // First look for index substitutions
-       for (unsigned i=0; i<ls.nops(); i++) {
-               if (is_equal(*(ls.op(i)).bp)) {
-
-                       // Substitution index->index
-                       if (is_ex_of_type(lr.op(i), idx))
-                               return lr.op(i);
-
-                       // Otherwise substitute value
-                       idx *i_copy = static_cast<idx *>(duplicate());
-                       i_copy->value = lr.op(i);
-                       i_copy->clearflag(status_flags::hash_calculated);
-                       return i_copy->setflag(status_flags::dynallocated);
-               }
+       exmap::const_iterator it = m.find(*this);
+       if (it != m.end()) {
+
+               // Substitution index->index
+               if (is_a<idx>(it->second) || (options & subs_options::really_subs_idx))
+                       return it->second;
+
+               // Otherwise substitute value
+               idx *i_copy = duplicate();
+               i_copy->value = it->second;
+               i_copy->clearflag(status_flags::hash_calculated);
+               return i_copy->setflag(status_flags::dynallocated);
        }
 
        // None, substitute objects in value (not in dimension)
-       const ex &subsed_value = value.subs(ls, lr, no_pattern);
+       const ex &subsed_value = value.subs(m, options);
        if (are_ex_trivially_equal(value, subsed_value))
                return *this;
 
-       idx *i_copy = static_cast<idx *>(duplicate());
+       idx *i_copy = duplicate();
        i_copy->value = subsed_value;
        i_copy->clearflag(status_flags::hash_calculated);
        return i_copy->setflag(status_flags::dynallocated);
 }
 
+/** Implementation of ex::diff() for an index always returns 0.
+ *
+ *  @see ex::diff */
+ex idx::derivative(const symbol & s) const
+{
+       return _ex0;
+}
+
 //////////
 // new virtual functions
 //////////
@@ -386,15 +416,19 @@ 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))
+       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 is_exactly_a<numeric>(dim) || is_exactly_a<numeric>(o.dim);
 }
 
 bool varidx::is_dummy_pair_same_type(const basic & other) const
@@ -424,25 +458,38 @@ bool spinidx::is_dummy_pair_same_type(const basic & other) const
 // non-virtual functions
 //////////
 
-ex varidx::toggle_variance(void) const
+ex idx::replace_dim(const ex & new_dim) const
 {
-       varidx *i_copy = static_cast<varidx *>(duplicate());
+       idx *i_copy = 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() const
+{
+       varidx *i_copy = duplicate();
        i_copy->covariant = !i_copy->covariant;
        i_copy->clearflag(status_flags::hash_calculated);
        return i_copy->setflag(status_flags::dynallocated);
 }
 
-ex spinidx::toggle_dot(void) const
+ex spinidx::toggle_dot() const
 {
-       spinidx *i_copy = static_cast<spinidx *>(duplicate());
+       spinidx *i_copy = duplicate();
        i_copy->dotted = !i_copy->dotted;
        i_copy->clearflag(status_flags::hash_calculated);
        return i_copy->setflag(status_flags::dynallocated);
 }
 
-ex spinidx::toggle_variance_dot(void) const
+ex spinidx::toggle_variance_dot() const
 {
-       spinidx *i_copy = static_cast<spinidx *>(duplicate());
+       spinidx *i_copy = duplicate();
        i_copy->covariant = !i_copy->covariant;
        i_copy->dotted = !i_copy->dotted;
        i_copy->clearflag(status_flags::hash_calculated);
@@ -456,7 +503,7 @@ ex spinidx::toggle_variance_dot(void) const
 bool is_dummy_pair(const idx & i1, const idx & i2)
 {
        // The indices must be of exactly the same type
-       if (i1.tinfo() != i2.tinfo())
+       if (typeid(i1) != typeid(i2))
                return false;
 
        // Same type, let the indices decide whether they are paired
@@ -466,10 +513,10 @@ 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));
+       return is_dummy_pair(ex_to<idx>(e1), ex_to<idx>(e2));
 }
 
 void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator itend, exvector & out_free, exvector & out_dummy)
@@ -483,7 +530,7 @@ void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator i
 
        // Only one index? Then it is a free one if it's not numeric
        if (itend - it == 1) {
-               if (ex_to_idx(*it).is_symbolic())
+               if (ex_to<idx>(*it).is_symbolic())
                        out_free.push_back(*it);
                return;
        }
@@ -503,13 +550,26 @@ void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator i
                        if (it == itend)
                                return;
                } else {
-                       if (!it->is_equal(*last) && ex_to_idx(*last).is_symbolic())
+                       if (!it->is_equal(*last) && ex_to<idx>(*last).is_symbolic())
                                out_free.push_back(*last);
                }
                last = it++;
        }
-       if (ex_to_idx(*last).is_symbolic())
+       if (ex_to<idx>(*last).is_symbolic())
                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<numeric>(dim2)))
+               return dim1;
+       else if (dim1 > dim2 || (!is_a<numeric>(dim1) && is_exactly_a<numeric>(dim2)))
+               return dim2;
+       else {
+               std::ostringstream s;
+               s << "minimal_dim(): index dimensions " << dim1 << " and " << dim2 << " cannot be ordered";
+               throw (std::runtime_error(s.str()));
+       }
+}
+
 } // namespace GiNaC