skeleton implementation of new color class

[ginac.git] / ginac / ncmul.cpp

diff --git a/ginac/ncmul.cpp b/ginac/ncmul.cpp
index 8964d6b7ddf2f946fa417be53ab5c7587f8ffb48..12c1d5e41fcf799eae4485967196222989a282a1 100644 (file)
--- a/ginac/ncmul.cpp
+++ b/ginac/ncmul.cpp
@@ -32,9 +32,7 @@
 #include "debugmsg.h"
 #include "utils.h"
 
-#ifndef NO_NAMESPACE_GINAC
 namespace GiNaC {
-#endif // ndef NO_NAMESPACE_GINAC
 
 GINAC_IMPLEMENT_REGISTERED_CLASS(ncmul, exprseq)
 
@@ -42,47 +40,14 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(ncmul, exprseq)
 // default constructor, destructor, copy constructor assignment operator and helpers
 //////////
 
-// public
-
 ncmul::ncmul()
 {
        debugmsg("ncmul default constructor",LOGLEVEL_CONSTRUCT);
        tinfo_key = TINFO_ncmul;
 }
 
-ncmul::~ncmul()
-{
-       debugmsg("ncmul destructor",LOGLEVEL_DESTRUCT);
-       destroy(false);
-}
-
-ncmul::ncmul(const ncmul & other)
-{
-       debugmsg("ncmul copy constructor",LOGLEVEL_CONSTRUCT);
-       copy(other);
-}
-
-const ncmul & ncmul::operator=(const ncmul & other)
-{
-       debugmsg("ncmul operator=",LOGLEVEL_ASSIGNMENT);
-       if (this != &other) {
-               destroy(true);
-               copy(other);
-       }
-       return *this;
-}
-
-// protected
-
-void ncmul::copy(const ncmul & other)
-{
-       inherited::copy(other);
-}
-
-void ncmul::destroy(bool call_parent)
-{
-       if (call_parent) inherited::destroy(call_parent);
-}
+DEFAULT_COPY(ncmul)
+DEFAULT_DESTROY(ncmul)
 
 //////////
 // other constructors
@@ -139,24 +104,7 @@ ncmul::ncmul(exvector * vp) : inherited(vp)
 // archiving
 //////////
 
-/** Construct object from archive_node. */
-ncmul::ncmul(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
-{
-       debugmsg("ncmul constructor from archive_node", LOGLEVEL_CONSTRUCT);
-}
-
-/** Unarchive the object. */
-ex ncmul::unarchive(const archive_node &n, const lst &sym_lst)
-{
-       return (new ncmul(n, sym_lst))->setflag(status_flags::dynallocated);
-}
-
-/** Archive the object. */
-void ncmul::archive(archive_node &n) const
-{
-       inherited::archive(n);
-}
-
+DEFAULT_ARCHIVING(ncmul)
        
 //////////
 // functions overriding virtual functions from bases classes
@@ -164,22 +112,16 @@ void ncmul::archive(archive_node &n) const
 
 // public
 
-basic * ncmul::duplicate() const
-{
-       debugmsg("ncmul duplicate",LOGLEVEL_ASSIGNMENT);
-       return new ncmul(*this);
-}
-
 void ncmul::print(std::ostream & os, unsigned upper_precedence) const
 {
        debugmsg("ncmul print",LOGLEVEL_PRINT);
-       printseq(os,'(','%',')',precedence,upper_precedence);
+       printseq(os,'(','*',')',precedence,upper_precedence);
 }
 
 void ncmul::printraw(std::ostream & os) const
 {
        debugmsg("ncmul printraw",LOGLEVEL_PRINT);
-       os << "%(";
+       os << "ncmul(";
        for (exvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
                (*it).bp->printraw(os);
                os << ",";
@@ -366,7 +308,7 @@ ex ncmul::eval(int level) const
        //                      *(c1,c2,ncmul(...)) (pull out commutative elements)
        //                  ncmul(x1,y1,x2,y2) -> *(ncmul(x1,x2),ncmul(y1,y2))
        //                      (collect elements of same type)
-       //                  ncmul(x1,x2,x3,...) -> x::eval_ncmul(x1,x2,x3,...)
+       //                  ncmul(x1,x2,x3,...) -> x::simplify_ncmul(x1,x2,x3,...)
        // the following rule would be nice, but produces a recursion,
        // which must be trapped by introducing a flag that the sub-ncmuls()
        // are already evaluated (maybe later...)
@@ -374,7 +316,7 @@ ex ncmul::eval(int level) const
        //                      ncmul(ncmul(x1,x2,...),X,ncmul(y1,y2,...)
        //                      (X noncommutative_composite)
 
-       if ((level==1)&&(flags & status_flags::evaluated)) {
+       if ((level==1) && (flags & status_flags::evaluated)) {
                return *this;
        }
 
@@ -383,16 +325,14 @@ ex ncmul::eval(int level) const
        // ncmul(...,*(x1,x2),...,ncmul(x3,x4),...) ->
        //     ncmul(...,x1,x2,...,x3,x4,...) (associativity)
        unsigned factors=0;
-       for (exvector::const_iterator cit=evaledseq.begin(); cit!=evaledseq.end(); ++cit) {
+       for (exvector::const_iterator cit=evaledseq.begin(); cit!=evaledseq.end(); ++cit)
                factors += count_factors(*cit);
-       }
-
+       
        exvector assocseq;
        assocseq.reserve(factors);
-       for (exvector::const_iterator cit=evaledseq.begin(); cit!=evaledseq.end(); ++cit) {
+       for (exvector::const_iterator cit=evaledseq.begin(); cit!=evaledseq.end(); ++cit)
                append_factors(assocseq,*cit);
-       }
-
+       
        // ncmul(x) -> x
        if (assocseq.size()==1) return *(seq.begin());
 
@@ -432,11 +372,10 @@ ex ncmul::eval(int level) const
                exvector noncommutativeseq;
                noncommutativeseq.reserve(assocseq.size()-count_commutative);
                for (i=0; i<assocseq.size(); ++i) {
-                       if (rettypes[i]==return_types::commutative) {
+                       if (rettypes[i]==return_types::commutative)
                                commutativeseq.push_back(assocseq[i]);
-                       } else {
+                       else
                                noncommutativeseq.push_back(assocseq[i]);
-                       }
                }
                commutativeseq.push_back((new ncmul(noncommutativeseq,1))->setflag(status_flags::dynallocated));
                return (new mul(commutativeseq))->setflag(status_flags::dynallocated);
@@ -484,16 +423,15 @@ ex ncmul::eval(int level) const
 #endif // def DO_GINAC_ASSERT
                
                // if all elements are of same type, simplify the string
-               if (evv.size()==1) {
+               if (evv.size()==1)
                        return evv[0][0].simplify_ncmul(evv[0]);
-               }
                
                exvector splitseq;
                splitseq.reserve(evv.size());
                for (i=0; i<evv.size(); ++i) {
                        splitseq.push_back((new ncmul(evv[i]))->setflag(status_flags::dynallocated));
                }
-
+               
                return (new mul(splitseq))->setflag(status_flags::dynallocated);
        }
        
@@ -501,20 +439,6 @@ ex ncmul::eval(int level) const
                                                                                  status_flags::evaluated);
 }
 
-exvector ncmul::get_indices(void) const
-{
-       // return union of indices of factors
-       exvector iv;
-       for (exvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-               exvector subiv=(*cit).get_indices();
-               iv.reserve(iv.size()+subiv.size());
-               for (exvector::const_iterator cit2=subiv.begin(); cit2!=subiv.end(); ++cit2) {
-                       iv.push_back(*cit2);
-               }
-       }
-       return iv;
-}
-
 ex ncmul::subs(const lst & ls, const lst & lr) const
 {
        return ncmul(subschildren(ls, lr));
@@ -624,7 +548,7 @@ const exvector & ncmul::get_factors(void) const
 
 // protected
 
-unsigned ncmul::precedence=50;
+unsigned ncmul::precedence = 50;
 
 //////////
 // friend functions
@@ -646,6 +570,4 @@ ex simplified_ncmul(const exvector & v)
                                       status_flags::evaluated);
 }
 
-#ifndef NO_NAMESPACE_GINAC
 } // namespace GiNaC
-#endif // ndef NO_NAMESPACE_GINAC