*/
#include <stdexcept>
+#include <algorithm>
#include "idx.h"
#include "symbol.h"
GINAC_IMPLEMENT_REGISTERED_CLASS(idx, basic)
GINAC_IMPLEMENT_REGISTERED_CLASS(varidx, idx)
+GINAC_IMPLEMENT_REGISTERED_CLASS(spinidx, varidx)
//////////
// default constructor, destructor, copy constructor assignment operator and helpers
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);
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
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
//////////
n.find_bool("covariant", covariant);
}
+spinidx::spinidx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
+{
+ debugmsg("spinidx constructor from archive_node", LOGLEVEL_CONSTRUCT);
+ n.find_bool("dotted", dotted);
+}
+
void idx::archive(archive_node &n) const
{
inherited::archive(n);
n.add_bool("covariant", covariant);
}
+void spinidx::archive(archive_node &n) const
+{
+ inherited::archive(n);
+ n.add_bool("dotted", dotted);
+}
+
DEFAULT_UNARCHIVE(idx)
DEFAULT_UNARCHIVE(varidx)
+DEFAULT_UNARCHIVE(spinidx)
//////////
// functions overriding virtual functions from bases classes
}
}
+void spinidx::print(const print_context & c, unsigned level) const
+{
+ debugmsg("spinidx 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")
+ << (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);
+
+ } else {
+
+ 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 << "}";
+ }
+}
+
bool idx::info(unsigned inf) const
{
if (inf == info_flags::idx)
return 0;
}
-ex idx::subs(const lst & ls, const lst & lr) const
+int spinidx::compare_same_type(const basic & other) const
+{
+ GINAC_ASSERT(is_of_type(other, spinidx));
+ const spinidx &o = static_cast<const spinidx &>(other);
+
+ // Check dottedness first so dummy indices will end up next to each other
+ if (dotted != o.dotted)
+ return dotted ? -1 : 1;
+
+ int cmpval = inherited::compare_same_type(other);
+ if (cmpval)
+ return cmpval;
+
+ return 0;
+}
+
+/** 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
+{
+ return *this;
+}
+
+bool idx::match(const ex & pattern, lst & repl_lst) 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);
+}
+
+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)
+ return false;
+ return inherited::match(pattern, repl_lst);
+}
+
+bool spinidx::match(const ex & pattern, lst & repl_lst) 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);
+}
+
+ex idx::subs(const lst & ls, const lst & lr, bool no_pattern) const
{
GINAC_ASSERT(ls.nops() == lr.nops());
}
// None, substitute objects in value (not in dimension)
- const ex &subsed_value = value.subs(ls, lr);
+ const ex &subsed_value = value.subs(ls, lr, no_pattern);
if (are_ex_trivially_equal(value, subsed_value))
return *this;
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
//////////
return inherited::is_dummy_pair_same_type(other);
}
+bool spinidx::is_dummy_pair_same_type(const basic & other) const
+{
+ const spinidx &o = static_cast<const spinidx &>(other);
+
+ // Dottedness must be the same
+ if (dotted != o.dotted)
+ return false;
+
+ return inherited::is_dummy_pair_same_type(other);
+}
+
+
//////////
// non-virtual functions
//////////
return i_copy->setflag(status_flags::dynallocated);
}
+ex spinidx::toggle_dot(void) const
+{
+ spinidx *i_copy = static_cast<spinidx *>(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
+{
+ spinidx *i_copy = static_cast<spinidx *>(duplicate());
+ 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);
+}
+
//////////
// global functions
//////////
if (!is_ex_of_type(e1, idx) || !is_ex_of_type(e2, idx))
return false;
- return is_dummy_pair(ex_to_idx(e1), ex_to_idx(e2));
-}
-
-/** Bring a vector of indices into a canonic order. Dummy indices will lie
- * next to each other after the sorting. */
-static void sort_index_vector(exvector &v)
-{
- // Nothing to sort if less than 2 elements
- if (v.size() < 2)
- return;
-
- // Simple bubble sort algorithm should be sufficient for the small
- // number of indices expected
- exvector::iterator it1 = v.begin(), itend = v.end(), next_to_last_idx = itend - 1;
- while (it1 != next_to_last_idx) {
- exvector::iterator it2 = it1 + 1;
- while (it2 != itend) {
- if (it1->compare(*it2) > 0)
- it1->swap(*it2);
- it2++;
- }
- it1++;
- }
+ 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)
{
out_free.clear();
// 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;
}
// Sort index vector. This will cause dummy indices come to lie next
// to each other (because the sort order is defined to guarantee this).
exvector v(it, itend);
- sort_index_vector(v);
+ shaker_sort(v.begin(), v.end(), ex_is_less(), ex_swap());
// Find dummy pairs and free indices
it = v.begin(); itend = v.end();
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);
}
-exvector index_set_difference(const exvector & set1, const exvector & set2)
-{
- exvector ret;
-
- exvector::const_iterator ait = set1.begin(), aitend = set1.end();
- while (ait != aitend) {
- exvector::const_iterator bit = set2.begin(), bitend = set2.end();
- bool found = false;
- while (bit != bitend) {
- if (ait->is_equal(*bit)) {
- found = true;
- break;
- }
- bit++;
- }
- if (!found)
- ret.push_back(*ait);
- ait++;
- }
-
- return ret;
-}
-
} // namespace GiNaC
git://www.ginac.de / ginac.git / blobdiff