X-Git-Url: https://ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Findexed.cpp;h=8151b080a4b2f685a96e2769495e393a1773d7a4;hb=0a0378c1130848c226a8ae496a336a6430a80deb;hp=ffcf5141734b25af6d402908562a16c1fbfa91df;hpb=a8507b8af1c08d9b27d98d57f95c7ca1a8671e27;p=ginac.git

diff --git a/ginac/indexed.cpp b/ginac/indexed.cpp
index ffcf5141..8151b080 100644
--- a/ginac/indexed.cpp
+++ b/ginac/indexed.cpp
@@ -1,8 +1,9 @@
 /** @file indexed.cpp
  *
- *  Implementation of GiNaC's index carrying objects.
- *
- *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
+ *  Implementation of GiNaC's index carrying objects. */
+
+/*
+ *  GiNaC Copyright (C) 1999-2000 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
@@ -21,7 +22,16 @@
 
 #include <string>
 
-#include "ginac.h"
+#include "indexed.h"
+#include "ex.h"
+#include "idx.h"
+#include "debugmsg.h"
+
+#ifndef NO_NAMESPACE_GINAC
+namespace GiNaC {
+#endif // ndef NO_NAMESPACE_GINAC
+
+GINAC_IMPLEMENT_REGISTERED_CLASS(indexed, exprseq)
 
 //////////
 // default constructor, destructor, copy constructor assignment operator and helpers
@@ -31,44 +41,44 @@
 
 indexed::indexed()
 {
-    debugmsg("indexed default constructor",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_INDEXED;
+	debugmsg("indexed default constructor",LOGLEVEL_CONSTRUCT);
+	tinfo_key=TINFO_indexed;
 }
 
 indexed::~indexed()
 {
-    debugmsg("indexed destructor",LOGLEVEL_DESTRUCT);
-    destroy(0);
+	debugmsg("indexed destructor",LOGLEVEL_DESTRUCT);
+	destroy(false);
 }
 
-indexed::indexed(indexed const & other)
+indexed::indexed(const indexed & other)
 {
-    debugmsg("indexed copy constructor",LOGLEVEL_CONSTRUCT);
-    copy (other);
+	debugmsg("indexed copy constructor",LOGLEVEL_CONSTRUCT);
+	copy (other);
 }
 
-indexed const & indexed::operator=(indexed const & other)
+const indexed & indexed::operator=(const indexed & other)
 {
-    debugmsg("indexed operator=",LOGLEVEL_ASSIGNMENT);
-    if (this != &other) {
-        destroy(1);
-        copy(other);
-    }
-    return *this;
+	debugmsg("indexed operator=",LOGLEVEL_ASSIGNMENT);
+	if (this != &other) {
+		destroy(true);
+		copy(other);
+	}
+	return *this;
 }
 
 // protected
 
-void indexed::copy(indexed const & other)
+void indexed::copy(const indexed & other)
 {
-    exprseq::copy(other);
+	inherited::copy(other);
 }
 
 void indexed::destroy(bool call_parent)
 {
-    if (call_parent) {
-        exprseq::destroy(call_parent);
-    }
+	if (call_parent) {
+		inherited::destroy(call_parent);
+	}
 }
 
 //////////
@@ -77,40 +87,71 @@ void indexed::destroy(bool call_parent)
 
 // public
 
-indexed::indexed(ex const & i1) : exprseq(i1)
+indexed::indexed(const ex & i1) : inherited(i1)
+{
+	debugmsg("indexed constructor from ex",LOGLEVEL_CONSTRUCT);
+	tinfo_key=TINFO_indexed;
+	GINAC_ASSERT(all_of_type_idx());
+}
+
+indexed::indexed(const ex & i1, const ex & i2) : inherited(i1,i2)
 {
-    debugmsg("indexed constructor from ex",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_INDEXED;
-    ASSERT(all_of_type_idx());
+	debugmsg("indexed constructor from ex,ex",LOGLEVEL_CONSTRUCT);
+	tinfo_key=TINFO_indexed;
+	GINAC_ASSERT(all_of_type_idx());
 }
 
-indexed::indexed(ex const & i1, ex const & i2) : exprseq(i1,i2)
+indexed::indexed(const ex & i1, const ex & i2, const ex & i3)
+  : inherited(i1,i2,i3)
 {
-    debugmsg("indexed constructor from ex,ex",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_INDEXED;
-    ASSERT(all_of_type_idx());
+	debugmsg("indexed constructor from ex,ex,ex",LOGLEVEL_CONSTRUCT);
+	tinfo_key=TINFO_indexed;
+	GINAC_ASSERT(all_of_type_idx());
 }
 
-indexed::indexed(ex const & i1, ex const & i2, ex const & i3)
-    : exprseq(i1,i2,i3)
+indexed::indexed(const ex & i1, const ex & i2, const ex & i3, const ex & i4)
+  : inherited(i1,i2,i3,i4)
 {
-    debugmsg("indexed constructor from ex,ex,ex",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_INDEXED;
-    ASSERT(all_of_type_idx());
+	debugmsg("indexed constructor from ex,ex,ex,ex",LOGLEVEL_CONSTRUCT);
+	tinfo_key=TINFO_indexed;
+	GINAC_ASSERT(all_of_type_idx());
 }
 
-indexed::indexed(exvector const & iv) : exprseq(iv)
+indexed::indexed(const exvector & iv) : inherited(iv)
 {
-    debugmsg("indexed constructor from exvector",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_INDEXED;
-    ASSERT(all_of_type_idx());
+	debugmsg("indexed constructor from exvector",LOGLEVEL_CONSTRUCT);
+	tinfo_key=TINFO_indexed;
+	GINAC_ASSERT(all_of_type_idx());
 }
 
-indexed::indexed(exvector * ivp) : exprseq(ivp)
+indexed::indexed(exvector * ivp) : inherited(ivp)
 {
-    debugmsg("indexed constructor from exvector *",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_INDEXED;
-    ASSERT(all_of_type_idx());
+	debugmsg("indexed constructor from exvector *",LOGLEVEL_CONSTRUCT);
+	tinfo_key=TINFO_indexed;
+	GINAC_ASSERT(all_of_type_idx());
+}
+
+//////////
+// archiving
+//////////
+
+/** Construct object from archive_node. */
+indexed::indexed(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
+{
+	debugmsg("indexed constructor from archive_node", LOGLEVEL_CONSTRUCT);
+	tinfo_key = TINFO_indexed;
+}
+
+/** Unarchive the object. */
+ex indexed::unarchive(const archive_node &n, const lst &sym_lst)
+{
+	return (new indexed(n, sym_lst))->setflag(status_flags::dynallocated);
+}
+
+/** Archive the object. */
+void indexed::archive(archive_node &n) const
+{
+	inherited::archive(n);
 }
 
 //////////
@@ -121,95 +162,102 @@ indexed::indexed(exvector * ivp) : exprseq(ivp)
 
 basic * indexed::duplicate() const
 {
-    debugmsg("indexed duplicate",LOGLEVEL_DUPLICATE);
-    return new indexed(*this);
+	debugmsg("indexed duplicate",LOGLEVEL_DUPLICATE);
+	return new indexed(*this);
 }
 
-void indexed::printraw(ostream & os) const
+void indexed::printraw(std::ostream & os) const
 {
-    debugmsg("indexed printraw",LOGLEVEL_PRINT);
-    os << "indexed(indices=";
-    printrawindices(os);
-    os << ",hash=" << hashvalue << ",flags=" << flags << ")";
+	debugmsg("indexed printraw",LOGLEVEL_PRINT);
+	os << "indexed(indices=";
+	printrawindices(os);
+	os << ",hash=" << hashvalue << ",flags=" << flags << ")";
 }
 
-void indexed::printtree(ostream & os, unsigned indent) const
+void indexed::printtree(std::ostream & os, unsigned indent) const
 {
-    debugmsg("indexed printtree",LOGLEVEL_PRINT);
-    os << string(indent,' ') << "indexed: " << seq.size() << " indices";
-    os << ",hash=" << hashvalue << ",flags=" << flags << endl;
-    printtreeindices(os,indent);
+	debugmsg("indexed printtree",LOGLEVEL_PRINT);
+	os << std::string(indent,' ') << "indexed: " << seq.size() << " indices";
+	os << ",hash=" << hashvalue << ",flags=" << flags << std::endl;
+	printtreeindices(os,indent);
 }
 
-void indexed::print(ostream & os, unsigned upper_precedence) const
+void indexed::print(std::ostream & os, unsigned upper_precedence) const
 {
-    debugmsg("indexed print",LOGLEVEL_PRINT);
-    os << "UNNAMEDINDEX";
-    printindices(os);
+	debugmsg("indexed print",LOGLEVEL_PRINT);
+	os << "UNNAMEDINDEX";
+	printindices(os);
 }
 
-void indexed::printcsrc(ostream & os, unsigned type,
+void indexed::printcsrc(std::ostream & os, unsigned type,
                         unsigned upper_precedence) const
 {
-    debugmsg("indexed print csrc",LOGLEVEL_PRINT);
-    print(os,upper_precedence);
+	debugmsg("indexed print csrc",LOGLEVEL_PRINT);
+	print(os,upper_precedence);
 }
 
 bool indexed::info(unsigned inf) const
 {
-    if (inf==info_flags::indexed) return true;
-    if (inf==info_flags::has_indices) return seq.size()!=0;
-    return exprseq::info(inf);
+	if (inf==info_flags::indexed) return true;
+	if (inf==info_flags::has_indices) return seq.size()!=0;
+	return inherited::info(inf);
 }
 
 exvector indexed::get_indices(void) const
 {
-    return seq;
-
-    /*
-    idxvector filtered_indices;
-    filtered_indices.reserve(indices.size());
-    for (idxvector::const_iterator cit=indices.begin(); cit!=indices.end(); ++cit) {
-        if ((*cit).get_type()==t) {
-            filtered_indices.push_back(*cit);
-        }
-    }
-    return filtered_indices;
-    */
+	return seq;
+
+	/*
+	idxvector filtered_indices;
+	filtered_indices.reserve(indices.size());
+	for (idxvector::const_iterator cit=indices.begin(); cit!=indices.end(); ++cit) {
+		if ((*cit).get_type()==t) {
+			filtered_indices.push_back(*cit);
+		}
+	}
+	return filtered_indices;
+	*/
 }
 
 // protected
 
-int indexed::compare_same_type(basic const & other) const
+/** Implementation of ex::diff() for an indexed object. It always returns 0.
+ *  @see ex::diff */
+ex indexed::derivative(const symbol & s) const
+{
+	return _ex0();
+}
+
+int indexed::compare_same_type(const basic & other) const
 {
-    ASSERT(is_of_type(other,indexed));
-    return exprseq::compare_same_type(other);
+	GINAC_ASSERT(is_of_type(other,indexed));
+	return inherited::compare_same_type(other);
 }
 
-bool indexed::is_equal_same_type(basic const & other) const
+bool indexed::is_equal_same_type(const basic & other) const
 {
-    ASSERT(is_of_type(other,indexed));
-    return exprseq::is_equal_same_type(other);
+	GINAC_ASSERT(is_of_type(other,indexed));
+	return inherited::is_equal_same_type(other);
 }
 
 unsigned indexed::return_type(void) const
 {
-    return return_types::noncommutative;
+	return return_types::noncommutative;
 }
    
 unsigned indexed::return_type_tinfo(void) const
 {
-    return tinfo_key;
+	return tinfo_key;
 }
 
-ex indexed::thisexprseq(exvector const & v) const
+ex indexed::thisexprseq(const exvector & v) const
 {
-    return indexed(v);
+	return indexed(v);
 }
 
 ex indexed::thisexprseq(exvector * vp) const
 {
-    return indexed(vp);
+	return indexed(vp);
 }
 
 //////////
@@ -224,53 +272,53 @@ ex indexed::thisexprseq(exvector * vp) const
 
 // protected
 
-void indexed::printrawindices(ostream & os) const
+void indexed::printrawindices(std::ostream & os) const
 {
-    if (seq.size()!=0) {
-        for (exvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-            (*cit).printraw(os);
-            os << ",";
-        }
-    }
+	if (seq.size()!=0) {
+		for (exvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
+			(*cit).printraw(os);
+			os << ",";
+		}
+	}
 }
 
-void indexed::printtreeindices(ostream & os, unsigned indent) const
+void indexed::printtreeindices(std::ostream & os, unsigned indent) const
 {
-    if (seq.size()!=0) {
-        for (exvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-            os << string(indent+delta_indent,' ');
-            (*cit).printraw(os);
-            os << endl;
-        }
-    }
+	if (seq.size()!=0) {
+		for (exvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
+			os << std::string(indent+delta_indent,' ');
+			(*cit).printraw(os);
+			os << std::endl;
+		}
+	}
 }
 
-void indexed::printindices(ostream & os) const
+void indexed::printindices(std::ostream & os) const
 {
-    if (seq.size()!=0) {
-        if (seq.size()>1) {
-            os << "{";
-        }
-        exvector::const_iterator last=seq.end()-1;
-        exvector::const_iterator cit=seq.begin();
-        for (; cit!=last; ++cit) {
-            (*cit).print(os);
-            os << ",";
-        }
-        (*cit).print(os);
-        if (seq.size()>1) {
-            os << "}";
-        }
-    }
+	if (seq.size()!=0) {
+		if (seq.size()>1) {
+			os << "{";
+		}
+		exvector::const_iterator last=seq.end()-1;
+		exvector::const_iterator cit=seq.begin();
+		for (; cit!=last; ++cit) {
+			(*cit).print(os);
+			os << ",";
+		}
+		(*cit).print(os);
+		if (seq.size()>1) {
+			os << "}";
+		}
+	}
 }
 
 bool indexed::all_of_type_idx(void) const
 {
-    // used only inside of ASSERTs
-    for (exvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-        if (!is_ex_of_type(*cit,idx)) return false;
-    }
-    return true;
+	// used only inside of ASSERTs
+	for (exvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
+		if (!is_ex_of_type(*cit,idx)) return false;
+	}
+	return true;
 }
 
 //////////
@@ -284,5 +332,8 @@ bool indexed::all_of_type_idx(void) const
 //////////
 
 const indexed some_indexed;
-type_info const & typeid_indexed=typeid(some_indexed);
+const type_info & typeid_indexed=typeid(some_indexed);
 
+#ifndef NO_NAMESPACE_GINAC
+} // namespace GiNaC
+#endif // ndef NO_NAMESPACE_GINAC