#include "idx.h"
#include "symbol.h"
#include "lst.h"
+#include "print.h"
#include "archive.h"
#include "utils.h"
#include "debugmsg.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 idx::printraw(std::ostream & os) const
+void idx::print(const print_context & c, unsigned level) const
{
- debugmsg("idx printraw", LOGLEVEL_PRINT);
+ debugmsg("idx print", LOGLEVEL_PRINT);
- os << class_name() << "(";
- value.printraw(os);
- os << ",dim=";
- dim.printraw(os);
- os << ",hash=" << hashvalue << ",flags=" << flags;
- os << ")";
+ 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::printtree(std::ostream & os, unsigned indent) const
+void varidx::print(const print_context & c, unsigned level) const
{
- debugmsg("idx printtree",LOGLEVEL_PRINT);
+ debugmsg("varidx print", LOGLEVEL_PRINT);
- os << std::string(indent, ' ') << "type=" << class_name();
- value.printtree(os, indent + delta_indent);
- os << std::string(indent, ' ');
- os << ", hash=" << hashvalue
- << " (0x" << std::hex << hashvalue << std::dec << ")"
- << ", flags=" << flags << std::endl;
-}
+ if (is_of_type(c, print_tree)) {
-void idx::print(std::ostream & os, unsigned upper_precedence) const
-{
- debugmsg("idx print", LOGLEVEL_PRINT);
+ 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);
- os << ".";
+ } else {
- bool need_parens = !(is_ex_exactly_of_type(value, numeric) || is_ex_of_type(value, symbol));
- if (need_parens)
- os << "(";
- os << value;
- if (need_parens)
- os << ")";
+ 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 << "(";
+ value.print(c);
+ if (need_parens)
+ c.s << ")";
+ }
}
-void varidx::print(std::ostream & os, unsigned upper_precedence) const
+void spinidx::print(const print_context & c, unsigned level) const
{
- debugmsg("varidx print", LOGLEVEL_PRINT);
-
- if (covariant)
- os << ".";
- else
- os << "~";
-
- bool need_parens = !(is_ex_exactly_of_type(value, numeric) || is_ex_of_type(value, symbol));
- if (need_parens)
- os << "(";
- os << value;
- if (need_parens)
- os << ")";
+ 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
return inherited::info(inf);
}
+unsigned idx::nops() const
+{
+ // don't count the dimension as that is not really a sub-expression
+ return 1;
+}
+
+ex & idx::let_op(int i)
+{
+ GINAC_ASSERT(i == 0);
+ return value;
+}
+
/** 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
return 0;
}
+int spinidx::compare_same_type(const basic & other) const
+{
+ GINAC_ASSERT(is_of_type(other, spinidx));
+ const spinidx &o = static_cast<const spinidx &>(other);
+
+ int cmpval = inherited::compare_same_type(other);
+ if (cmpval)
+ return cmpval;
+
+ // Check variance and dottedness last so dummy indices will end up next to each other
+ if (covariant != o.covariant)
+ return covariant ? -1 : 1;
+ if (dotted != o.dotted)
+ return dotted ? -1 : 1;
+
+ return 0;
+}
+
ex idx::subs(const lst & ls, const lst & lr) const
{
GINAC_ASSERT(ls.nops() == lr.nops());
// 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);
}
}
idx *i_copy = static_cast<idx *>(duplicate());
i_copy->value = subsed_value;
+ i_copy->clearflag(status_flags::hash_calculated);
return i_copy->setflag(status_flags::dynallocated);
}
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
//////////
git://www.ginac.de / ginac.git / blobdiff