X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fidx.cpp;h=90ac3a425a35bfd6b2158e60b40eb8e8d36277fb;hp=44427a6ac08e3e7db642bf2d1381e3491ba1612a;hb=6c9a7dfd6b92368b21a2fe5aaf3638bc849099ba;hpb=ae41c1e2347d2308a1019746b8d7e3feed02e9e6;ds=sidebyside

diff --git a/ginac/idx.cpp b/ginac/idx.cpp
index 44427a6a..90ac3a42 100644
--- a/ginac/idx.cpp
+++ b/ginac/idx.cpp
@@ -34,6 +34,7 @@ namespace GiNaC {
 
 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
@@ -50,6 +51,12 @@ varidx::varidx() : covariant(false)
 	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);
@@ -63,8 +70,15 @@ void varidx::copy(const varidx & 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
@@ -84,6 +98,12 @@ varidx::varidx(const ex & v, const ex & d, bool cov) : inherited(v, d), covarian
 	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
 //////////
@@ -101,6 +121,12 @@ varidx::varidx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst
 	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);
@@ -114,8 +140,15 @@ void varidx::archive(archive_node &n) const
 	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
@@ -178,6 +211,47 @@ void varidx::print(const print_context & c, unsigned level) const
 	}
 }
 
+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)
@@ -225,6 +299,24 @@ int varidx::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());
@@ -287,6 +379,18 @@ bool varidx::is_dummy_pair_same_type(const basic & other) const
 	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
 //////////
@@ -299,6 +403,23 @@ ex varidx::toggle_variance(void) const
 	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
 //////////