#ifndef around namespace GiNaC { }
[ginac.git] / ginac / simp_lor.cpp
index 32d05b0c9d0ed7154b4d54a4953a63f321d0ec5b..a102b74e4d3a36abe4b9852c0384e39e5a43acfd 100644 (file)
@@ -3,6 +3,24 @@
  *  Implementation of GiNaC's simp_lor objects.
  *  No real implementation yet, to be done.     */
 
+/*
+ *  GiNaC Copyright (C) 1999 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
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 #include <string>
 #include <list>
 #include <algorithm>
 #include <stdexcept>
 #include <map>
 
-#include "ginac.h"
+#include "simp_lor.h"
+#include "ex.h"
+#include "mul.h"
+#include "symbol.h"
+#include "debugmsg.h"
+
+#ifndef NO_GINAC_NAMESPACE
+namespace GiNaC {
+#endif // ndef NO_GINAC_NAMESPACE
 
 //////////
 // default constructor, destructor, copy constructor assignment operator and helpers
@@ -21,7 +47,7 @@
 simp_lor::simp_lor() : type(invalid)
 {
     debugmsg("simp_lor default constructor",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_SIMP_LOR;
+    tinfo_key=TINFO_simp_lor;
 }
 
 simp_lor::~simp_lor()
@@ -71,39 +97,39 @@ void simp_lor::destroy(bool call_parent)
 simp_lor::simp_lor(simp_lor_types const t) : type(t)
 {
     debugmsg("simp_lor constructor from simp_lor_types",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_SIMP_LOR;
+    tinfo_key=TINFO_simp_lor;
 }
 
 simp_lor::simp_lor(simp_lor_types const t, ex const & i1, ex const & i2) :
     indexed(i1,i2), type(t)
 {
     debugmsg("simp_lor constructor from simp_lor_types,ex,ex",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_SIMP_LOR;
-    ASSERT(all_of_type_lorentzidx());
+    tinfo_key=TINFO_simp_lor;
+    GINAC_ASSERT(all_of_type_lorentzidx());
 }
 
 simp_lor::simp_lor(simp_lor_types const t, string const & n, ex const & i1) :
     indexed(i1), type(t), name(n)
 {
     debugmsg("simp_lor constructor from simp_lor_types,string,ex",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_SIMP_LOR;
-    ASSERT(all_of_type_lorentzidx());
+    tinfo_key=TINFO_simp_lor;
+    GINAC_ASSERT(all_of_type_lorentzidx());
 }
 
 simp_lor::simp_lor(simp_lor_types const t, string const & n, exvector const & iv) :
     indexed(iv), type(t), name(n)
 {
     debugmsg("simp_lor constructor from simp_lor_types,string,exvector",LOGLEVEL_CONSTRUCT);
-    tinfo_key=TINFO_SIMP_LOR;
-    ASSERT(all_of_type_lorentzidx());
+    tinfo_key=TINFO_simp_lor;
+    GINAC_ASSERT(all_of_type_lorentzidx());
 }
 
 simp_lor::simp_lor(simp_lor_types const t, string const & 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;
-    ASSERT(all_of_type_lorentzidx());
+    tinfo_key=TINFO_simp_lor;
+    GINAC_ASSERT(all_of_type_lorentzidx());
 }
 
 //////////
@@ -215,7 +241,7 @@ ex simp_lor::eval(int level) const
 
 int simp_lor::compare_same_type(basic const & other) const
 {
-    ASSERT(other.tinfo() == TINFO_SIMP_LOR);
+    GINAC_ASSERT(other.tinfo() == TINFO_simp_lor);
     const simp_lor *o = static_cast<const simp_lor *>(&other);
     if (type==o->type) {
         if (name==o->name) {
@@ -228,7 +254,7 @@ int simp_lor::compare_same_type(basic const & other) const
 
 bool simp_lor::is_equal_same_type(basic const & other) const
 {
-    ASSERT(other.tinfo() == TINFO_SIMP_LOR);
+    GINAC_ASSERT(other.tinfo() == TINFO_simp_lor);
     const simp_lor *o = static_cast<const simp_lor *>(&other);
     if (type!=o->type) return false;
     if (name!=o->name) return false;
@@ -305,7 +331,7 @@ simp_lor lor_vec(string const & n, ex const & mu)
 
 ex simplify_simp_lor_mul(ex const & m, scalar_products const & sp)
 {
-    ASSERT(is_ex_exactly_of_type(m,mul));
+    GINAC_ASSERT(is_ex_exactly_of_type(m,mul));
     exvector v_contracted;
 
     // collect factors in an exvector, store squares twice
@@ -313,7 +339,7 @@ ex simplify_simp_lor_mul(ex const & m, scalar_products const & sp)
     v_contracted.reserve(2*n);
     for (int i=0; i<n; ++i) {
         ex f=m.op(i);
-        if (is_ex_exactly_of_type(f,power)&&f.op(1)==2) {
+        if (is_ex_exactly_of_type(f,power)&&f.op(1).is_equal(exTWO())) {
             v_contracted.push_back(f.op(0));
             v_contracted.push_back(f.op(0));
         } else {
@@ -330,11 +356,11 @@ ex simplify_simp_lor_mul(ex const & m, scalar_products const & sp)
         if (is_ex_exactly_of_type(*it,simp_lor) &&
             (ex_to_simp_lor(*it).type==simp_lor::simp_lor_g)) {
             simp_lor const & g=ex_to_simp_lor(*it);
-            ASSERT(g.seq.size()==2);
+            GINAC_ASSERT(g.seq.size()==2);
             idx const & first_idx=ex_to_lorentzidx(g.seq[0]);
             idx const & second_idx=ex_to_lorentzidx(g.seq[1]);
             // g_{mu,mu} should have been contracted in simp_lor::eval()
-            ASSERT(!first_idx.is_equal(second_idx));
+            GINAC_ASSERT(!first_idx.is_equal(second_idx));
             ex saved_g=*it; // save to restore it later
 
             // try to contract first index
@@ -347,7 +373,7 @@ ex simplify_simp_lor_mul(ex const & m, scalar_products const & sp)
                     *it=saved_g;
                 } else {
                     // a contracted index should occur exactly once
-                    ASSERT(replacements==1);
+                    GINAC_ASSERT(replacements==1);
                     *it=exONE();
                     something_changed=true;
                 }
@@ -363,7 +389,7 @@ ex simplify_simp_lor_mul(ex const & m, scalar_products const & sp)
                     *it=saved_g;
                 } else {
                     // a contracted index should occur exactly once
-                    ASSERT(replacements==1);
+                    GINAC_ASSERT(replacements==1);
                     *it=exONE();
                     something_changed=true;
                 }
@@ -384,8 +410,8 @@ ex simplify_simp_lor_mul(ex const & m, scalar_products const & sp)
                     (ex_to_simp_lor(*it2).type==simp_lor::simp_lor_vec)) {
                     simp_lor const & vec1=ex_to_simp_lor(*it1);
                     simp_lor const & vec2=ex_to_simp_lor(*it2);
-                    ASSERT(vec1.seq.size()==1);
-                    ASSERT(vec2.seq.size()==1);
+                    GINAC_ASSERT(vec1.seq.size()==1);
+                    GINAC_ASSERT(vec2.seq.size()==1);
                     lorentzidx const & idx1=ex_to_lorentzidx(vec1.seq[0]);
                     lorentzidx const & idx2=ex_to_lorentzidx(vec2.seq[0]);
                     if (idx1.is_symbolic() &&
@@ -482,12 +508,13 @@ void scalar_products::debugprint(void) const
 
 spmapkey scalar_products::make_key(simp_lor const & v1, simp_lor const & v2)
 {
-    ASSERT(v1.type==simp_lor::simp_lor_vec);
-    ASSERT(v2.type==simp_lor::simp_lor_vec);
+    GINAC_ASSERT(v1.type==simp_lor::simp_lor_vec);
+    GINAC_ASSERT(v2.type==simp_lor::simp_lor_vec);
     lorentzidx anon=ex_to_lorentzidx(v1.seq[0]).create_anonymous_representative();
-    ASSERT(anon.is_equal_same_type(ex_to_lorentzidx(v2.seq[0]).create_anonymous_representative()));
+    GINAC_ASSERT(anon.is_equal_same_type(ex_to_lorentzidx(v2.seq[0]).create_anonymous_representative()));
     return spmapkey(strstrpair(v1.name,v2.name),anon);
 }
 
-
-
+#ifndef NO_GINAC_NAMESPACE
+} // namespace GiNaC
+#endif // ndef NO_GINAC_NAMESPACE