A term

Toggle Background

Now we have designed and implemented all objects we identified in our original problem. However, we already mentioned that it will be useful to define an additional object Term. The convenience of an object Term is related to the mathematical concept of closedness (in the sense of group theory): The application of the anticommutation rule will transform a pure product of second quantized operators into a sum of a pure product of second quantized operators and a product of second quantized operators multiplied by product of Kronecker symbols. All objects to represent this algebraic structure have already been designed except for the mixed product of second quantized operators and Kronecker symbols. Exactly this shall be a Term. We shall illustrate this using the following example:

$$\underbrace{{ \underbrace{\hat a_q^\dagger \hat a_p \hat a_s^\dagger \hat a_r}_{\mbox{\tt Product$<$SQOperator$>$}}}}_{{ \mbox{\tt Term}}}^{}$$ = $$\underbrace{{ \underbrace{ \underbrace{\delta_{ps}}_{\mbox{\tt Pr... ...<$SQOperator$>$}}}_{ \mbox{\tt Term}}}}_{{ \mbox{\tt Sum$<$Term, int$>$}}}^{}$$

Now you see the expressive power of templates once more.

Here is the source: Interface: Term.H

 #ifndef Term_H
 #define Term_H
 
 #include "Product.H"
 #include "SQOperator.H"
 #include "Kronecker.H"
 #include "Sum.H"
 
 
 #include <iostream>
 
 using namespace std;
 
 /*!
     A term consists of a Product of SQOperators and a Product of Kroneckers
 */
 class Term {
 public:
     //! construct from Product<SQOperator>, Product<Kronecker> will be empty
     Term(Product<SQOperator> const & opProd);
 
     //! construct from Product<SQOperator> and Product<Kronecker>
     Term(Product<SQOperator> const & opProd, Product<Kronecker> const & kProd);
     
     //! return contained Product<SQOperator>
     Product<SQOperator> opProd() const;
 
     //! return contained Product<Kronecker>
     Product<Kronecker>  kProd() const;
 
     //! artificial ordering
     bool operator < (Term const & t) const;
     
     //! calculate normal ordering
     Sum<Term, int>  normalOrder() const;
 
     //! calculate normal ordering, fully contracted terms only
     Sum<Term, int>  normalOrder_fullyContractedOnly() const;
 
 private:
     Sum<Term, int>  normalOrder(bool fullyContractedOnly) const;
 
 Product<SQOperator> _opProd;
 Product<Kronecker>  _kProd;
 };
 
 //! output operator for Term
 ostream & operator << (ostream & o, Term const & t);
 
 #endif

Implementation: Term.C

 #include "Term.H"
 
 
 Term::Term(Product<SQOperator> const & opProd) :
     _opProd(opProd) {}
 
 Term::Term(Product<SQOperator> const & opProd, Product<Kronecker> const & kProd) :
     _opProd(opProd), _kProd(kProd) {}
 
 
 Product<SQOperator> Term::opProd() const
 {   return _opProd; }
 
 Product<Kronecker>  Term::kProd() const
 {   return _kProd;  }
 
 
 bool Term::operator < (Term const & t) const
 {
     if ( _kProd<t._kProd )
         return true;
     if ( t._kProd<_kProd )
         return false;
     return _opProd<t._opProd;
 return true;
 }
 
 
 ostream & operator << (ostream & o, Term const & t)
 {
     o << t.kProd();
     if ( t.kProd().size()>0 && t.opProd().size()>0 )
         o << "*";
     o << t.opProd();
 return o;
 }

Let's test it: Term_Test.C

 #include "Term.H"
 #include "Sum.H"
 
 using namespace std;
 
 int main()
 {
 Product<SQOperator> p;
 
     p *= SQOperator('i');
     p *= SQOperator('j');
     p *= SQOperator('A');
     p *= SQOperator('B');
 
 
 Product<Kronecker>  k;
 
     k *= Kronecker('x', 'y');
     k *= Kronecker('p', 'q');
 
 Term    term(p, k);
 
     cout << term << endl;
 
 Sum<Term, int>  s;
     
     s += term;
     s += term;
     s += term;
 
     cout << s << endl;
 
     return 0;
 }

The output is (download tarball into a fresh directory, extract, compile and link with g++ *.C, run a.out)

d(xy)*d(pq)*i*j*A*B
3*d(xy)*d(pq)*i*j*A*B

This is no longer completely trivial...