* Implementation of GiNaC's indices. */
/*
- * GiNaC Copyright (C) 1999-2005 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2016 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
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#include <iostream>
-#include <sstream>
-#include <stdexcept>
-
#include "idx.h"
#include "symbol.h"
#include "lst.h"
#include "operators.h"
#include "archive.h"
#include "utils.h"
+#include "hash_seed.h"
+
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
namespace GiNaC {
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,
// default constructor
//////////
-idx::idx() : inherited(TINFO_idx) {}
+idx::idx() {}
varidx::varidx() : covariant(false)
{
- tinfo_key = TINFO_varidx;
}
spinidx::spinidx() : dotted(false)
{
- tinfo_key = TINFO_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)
{
if (is_dim_numeric())
if (!dim.info(info_flags::posint))
varidx::varidx(const ex & v, const ex & d, bool cov) : inherited(v, d), covariant(cov)
{
- tinfo_key = TINFO_varidx;
}
spinidx::spinidx(const ex & v, const ex & d, bool cov, bool dot) : inherited(v, d, cov), dotted(dot)
{
- tinfo_key = TINFO_spinidx;
}
//////////
// archiving
//////////
-idx::idx(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
+void idx::read_archive(const archive_node& n, lst& sym_lst)
{
+ 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, lst &sym_lst) : inherited(n, sym_lst)
+void varidx::read_archive(const archive_node& n, lst& sym_lst)
{
+ inherited::read_archive(n, sym_lst);
n.find_bool("covariant", covariant);
}
+GINAC_BIND_UNARCHIVER(varidx);
-spinidx::spinidx(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
+void spinidx::read_archive(const archive_node& n, lst& sym_lst)
{
+ inherited::read_archive(n, sym_lst);
n.find_bool("dotted", dotted);
}
+GINAC_BIND_UNARCHIVER(spinidx);
void idx::archive(archive_node &n) const
{
n.add_bool("dotted", dotted);
}
-DEFAULT_UNARCHIVE(idx)
-DEFAULT_UNARCHIVE(varidx)
-DEFAULT_UNARCHIVE(spinidx)
-
//////////
// functions overriding virtual functions from base classes
//////////
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);
+ c.s << "]";
+}
+
void idx::do_print_tree(const print_tree & c, unsigned level) const
{
c.s << std::string(level, ' ') << class_name() << " @" << this
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);
}
return *this;
else {
idx *copy = duplicate();
- copy->setflag(status_flags::dynallocated);
copy->clearflag(status_flags::hash_calculated);
copy->value = mapped_value;
return *copy;
// 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 = golden_ratio_hash(tinfo());
+ unsigned v = make_hash_seed(typeid(*this));
v = rotate_left(v);
v ^= value.gethash();
/** 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
+ex idx::evalf() const
{
return *this;
}
if (it != m.end()) {
// Substitution index->index
- if (is_a<idx>(it->second))
+ 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);
+ return *i_copy;
}
// None, substitute objects in value (not in dimension)
idx *i_copy = duplicate();
i_copy->value = subsed_value;
i_copy->clearflag(status_flags::hash_calculated);
- return i_copy->setflag(status_flags::dynallocated);
+ return *i_copy;
}
/** Implementation of ex::diff() for an index always returns 0.
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)));
+ return is_exactly_a<numeric>(dim) || is_exactly_a<numeric>(o.dim);
}
bool varidx::is_dummy_pair_same_type(const basic & other) const
idx *i_copy = duplicate();
i_copy->dim = new_dim;
i_copy->clearflag(status_flags::hash_calculated);
- return i_copy->setflag(status_flags::dynallocated);
+ return *i_copy;
}
ex idx::minimal_dim(const idx & other) 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);
+ return *i_copy;
}
ex spinidx::toggle_dot() const
spinidx *i_copy = duplicate();
i_copy->dotted = !i_copy->dotted;
i_copy->clearflag(status_flags::hash_calculated);
- return i_copy->setflag(status_flags::dynallocated);
+ return *i_copy;
}
ex spinidx::toggle_variance_dot() const
i_copy->covariant = !i_copy->covariant;
i_copy->dotted = !i_copy->dotted;
i_copy->clearflag(status_flags::hash_calculated);
- return i_copy->setflag(status_flags::dynallocated);
+ return *i_copy;
}
//////////
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
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)))
+ if (dim1.is_equal(dim2) || dim1 < dim2 || (is_exactly_a<numeric>(dim1) && !is_a<numeric>(dim2)))
return dim1;
- else if (dim1 > dim2 || (is_a<symbol>(dim1) && is_exactly_a<numeric>(dim2)))
+ else if (dim1 > dim2 || (!is_a<numeric>(dim1) && is_exactly_a<numeric>(dim2)))
return dim2;
else {
std::ostringstream s;
git://www.ginac.de / ginac.git / blobdiff