* No real implementation yet, to be done. */
/*
- * GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2001 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
#include "simp_lor.h"
#include "ex.h"
#include "mul.h"
-#include "symbol.h"
+#include "archive.h"
#include "debugmsg.h"
#include "utils.h"
-#ifndef NO_NAMESPACE_GINAC
namespace GiNaC {
-#endif // ndef NO_NAMESPACE_GINAC
+
+GINAC_IMPLEMENT_REGISTERED_CLASS(simp_lor, indexed)
//////////
// default constructor, destructor, copy constructor assignment operator and helpers
tinfo_key=TINFO_simp_lor;
}
-simp_lor::~simp_lor()
-{
- debugmsg("simp_lor destructor",LOGLEVEL_DESTRUCT);
- destroy(0);
-}
-
-simp_lor::simp_lor(const simp_lor & other)
-{
- debugmsg("simp_lor copy constructor",LOGLEVEL_CONSTRUCT);
- copy (other);
-}
-
-const simp_lor & simp_lor::operator=(const simp_lor & other)
-{
- debugmsg("simp_lor operator=",LOGLEVEL_ASSIGNMENT);
- if (this != &other) {
- destroy(1);
- copy(other);
- }
- return *this;
-}
-
// protected
void simp_lor::copy(const simp_lor & other)
tinfo_key=TINFO_simp_lor;
}
-simp_lor::simp_lor(simp_lor_types const t, const ex & i1, const ex & i2) :
- indexed(i1,i2), type(t)
+simp_lor::simp_lor(simp_lor_types const t, const ex & i1, const ex & i2)
+ : indexed(i1,i2), type(t)
{
debugmsg("simp_lor constructor from simp_lor_types,ex,ex",LOGLEVEL_CONSTRUCT);
tinfo_key=TINFO_simp_lor;
GINAC_ASSERT(all_of_type_lorentzidx());
}
-simp_lor::simp_lor(simp_lor_types const t, const std::string & n, const ex & i1) :
- indexed(i1), type(t), name(n)
+simp_lor::simp_lor(simp_lor_types const t, const std::string & n, const ex & i1)
+ : indexed(i1), type(t), name(n)
{
debugmsg("simp_lor constructor from simp_lor_types,string,ex",LOGLEVEL_CONSTRUCT);
tinfo_key=TINFO_simp_lor;
GINAC_ASSERT(all_of_type_lorentzidx());
}
-simp_lor::simp_lor(simp_lor_types const t, const std::string & n, const exvector & iv) :
- indexed(iv), type(t), name(n)
+simp_lor::simp_lor(simp_lor_types const t, const std::string & n, const exvector & iv)
+ : indexed(iv), type(t), name(n)
{
debugmsg("simp_lor constructor from simp_lor_types,string,exvector",LOGLEVEL_CONSTRUCT);
tinfo_key=TINFO_simp_lor;
GINAC_ASSERT(all_of_type_lorentzidx());
}
-simp_lor::simp_lor(simp_lor_types const t, const std::string & n, exvector * ivp) :
- indexed(ivp), type(t), name(n)
+simp_lor::simp_lor(simp_lor_types const t, const std::string & n, exvector * ivp)
+ : indexed(ivp), type(t), name(n)
{
debugmsg("simp_lor constructor from simp_lor_types,string,exvector*",LOGLEVEL_CONSTRUCT);
tinfo_key=TINFO_simp_lor;
}
//////////
-// functions overriding virtual functions from bases classes
+// archiving
//////////
-// public
+/** Construct object from archive_node. */
+simp_lor::simp_lor(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
+{
+ debugmsg("simp_lor constructor from archive_node", LOGLEVEL_CONSTRUCT);
+ unsigned int ty;
+ if (!(n.find_unsigned("type", ty)))
+ throw (std::runtime_error("unknown simp_lor type in archive"));
+ type = (simp_lor_types)ty;
+ n.find_string("name", name);
+}
+
+/** Unarchive the object. */
+ex simp_lor::unarchive(const archive_node &n, const lst &sym_lst)
+{
+ return (new simp_lor(n, sym_lst))->setflag(status_flags::dynallocated);
+}
-basic * simp_lor::duplicate() const
+/** Archive the object. */
+void simp_lor::archive(archive_node &n) const
{
- debugmsg("simp_lor duplicate",LOGLEVEL_DUPLICATE);
- return new simp_lor(*this);
+ inherited::archive(n);
+ n.add_unsigned("type", type);
+ n.add_string("name", name);
}
+
+//////////
+// functions overriding virtual functions from bases classes
+//////////
+
+// public
+
void simp_lor::printraw(std::ostream & os) const
{
debugmsg("simp_lor printraw",LOGLEVEL_PRINT);
// at least one off-diagonal
return _ex0();
}
- } else if (idx1.is_symbolic() &&
- idx1.is_co_contra_pair(idx2)) {
- return Dim()-idx1.get_dim_parallel_space();
+ } else if (idx1.is_symbolic() && idx1.is_co_contra_pair(idx2)) {
+ if (idx1.is_orthogonal_only())
+ return Dim() - idx1.get_dim_parallel_space();
+ else
+ return Dim();
}
}
// none
-//////////
-// global constants
-//////////
-
-const simp_lor some_simp_lor;
-const type_info & typeid_simp_lor = typeid(some_simp_lor);
-
//////////
// friend functions
//////////
// try to contract first index
replacements=0;
if (first_idx.is_symbolic()) {
- replacements = subs_index_in_exvector(v_contracted,
- first_idx.toggle_covariant(),second_idx);
+ replacements = subs_index_in_exvector(v_contracted, first_idx.toggle_covariant(),second_idx);
if (replacements==0) {
// not contracted, restore g object
*it=saved_g;
// try second index only if first was not contracted
if ((replacements==0)&&(second_idx.is_symbolic())) {
// first index not contracted, *it is again the original g object
- replacements = subs_index_in_exvector(v_contracted,
- second_idx.toggle_covariant(),first_idx);
+ replacements = subs_index_in_exvector(v_contracted, second_idx.toggle_covariant(),first_idx);
if (replacements==0) {
// not contracted except in itself, restore g object
*it=saved_g;
ex simplify_simp_lor(const ex & e, const scalar_products & sp)
{
// all simplification is done on expanded objects
- ex e_expanded=e.expand();
+ ex e_expanded = e.expand();
// simplification of sum=sum of simplifications
if (is_ex_exactly_of_type(e_expanded,add)) {
ex sum=_ex0();
for (unsigned i=0; i<e_expanded.nops(); ++i)
sum += simplify_simp_lor(e_expanded.op(i),sp);
-
+
return sum;
}
return e_expanded;
}
-//ex Dim(void) // FIXME: what's going on here?
-//{
-// static symbol * d=new symbol("dim");
-// return *d;
-//}
-
//////////
// helper classes
//////////
void scalar_products::reg(const simp_lor & v1, const simp_lor & v2,
- const ex & sp)
+ const ex & sp)
{
if (v1.compare_same_type(v2)>0) {
reg(v2,v1,sp);
ex scalar_products::evaluate(const simp_lor & v1, const simp_lor & v2) const
{
- if (v1.compare_same_type(v2)>0) {
- return evaluate(v2,v1);
- }
- return spm.find(make_key(v1,v2))->second;
+ if (v1.compare_same_type(v2)>0)
+ return evaluate(v2, v1);
+
+ return (*spm.find(make_key(v1,v2))).second;
}
void scalar_products::debugprint(void) const
for (spmap::const_iterator cit=spm.begin(); cit!=spm.end(); ++cit) {
const spmapkey & k=(*cit).first;
std::cerr << "item key=((" << k.first.first
- << "," << k.first.second << "),";
- k.second.printraw(cerr);
- cerr << ") value=" << (*cit).second << std::endl;
+ << "," << k.first.second << "),";
+ k.second.printraw(std::cerr);
+ std::cerr << ") value=" << (*cit).second << std::endl;
}
}
return spmapkey(strstrpair(v1.name,v2.name),anon);
}
-#ifndef NO_NAMESPACE_GINAC
} // namespace GiNaC
-#endif // ndef NO_NAMESPACE_GINAC
projects / ginac.git / blobdiff