* Implementation of GiNaC's indices. */
/*
- * GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2008 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 <iostream>
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() : inherited(&idx::tinfo_static) {}
varidx::varidx() : covariant(false)
{
- tinfo_key = TINFO_varidx;
+ tinfo_key = &varidx::tinfo_static;
}
spinidx::spinidx() : dotted(false)
{
- tinfo_key = TINFO_spinidx;
+ tinfo_key = &spinidx::tinfo_static;
}
//////////
// 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) : inherited(&idx::tinfo_static), 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;
+ tinfo_key = &varidx::tinfo_static;
}
spinidx::spinidx(const ex & v, const ex & d, bool cov, bool dot) : inherited(v, d, cov), dotted(dot)
{
- tinfo_key = TINFO_spinidx;
+ tinfo_key = &spinidx::tinfo_static;
}
//////////
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);
}
ex idx::map(map_function & f) const
{
- idx *copy = duplicate();
- copy->setflag(status_flags::dynallocated);
- copy->clearflag(status_flags::hash_calculated);
- copy->value = f(value);
- return *copy;
+ 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
// 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());
+ const void* this_tinfo = (const void*)(typeid(*this).name());
+ unsigned v = golden_ratio_hash((p_int)this_tinfo);
v = rotate_left(v);
v ^= value.gethash();
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
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
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;