braket.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// SOSpin Library
// Copyright (C) 2015 SOSpin Project
//
//   Authors:
//
//     Nuno Cardoso (nuno.cardoso@tecnico.ulisboa.pt)
//     David Emmanuel-Costa (david.costa@tecnico.ulisboa.pt)
//     Nuno Gonçalves (nunogon@deec.uc.pt)
//     Catarina Simoes (csimoes@ulg.ac.be)
//
// ----------------------------------------------------------------------------
// This file is part of SOSpin Library.
//
// SOSpin Library 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 3 of the License, or any
// later version.
//
// SOSpin Library 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 SOSpin Library.  If not, see <http://www.gnu.org/licenses/>.
// ----------------------------------------------------------------------------

//       braket.h created on 27/02/2015 
//
//      This file contains the functions necessary to do things 
//   in the SOSpin Library.
//
//      Revision 1.1 28/02/2015 23:19:29 david
//      License updated 
//


#ifndef BRAKET_H
#define BRAKET_H
 
#include <iostream>
#include <string>  
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <vector>
#include <algorithm> 
#include <list>  

#include "dlist.h"
#include "enum.h"


using namespace std;


namespace sospin {







void setSimplifyIndexSum();

void unsetSimplifyIndexSum();


class BraketOneTerm{
private:
  int index;
  string constpart;
  list<DList> term;

  bool EvaluateEps_1stPass(OPMode oper );

  void EvaluateEps_2ndPass(OPMode oper );

public:
  BraketOneTerm();
  BraketOneTerm(const DList &d0);
  BraketOneTerm(int indexin, string constpartin, const DList &d0);
  BraketOneTerm(int indexin, string constpartin, list<DList> termin);
  BraketOneTerm(int indexin, string constpartin, BraketOneTerm& termin);
  ~BraketOneTerm();
  void clear();

  list<DList>& GetTerm();
  string& GetConst();
  int& GetIndex();


  bool Simplify(OPMode operation);
  bool checkindex();


  void expfromForm(string a);
  void rearrange();
  bool isempty();

  bool EvaluateToDeltas(OPMode oper );
  bool EvaluateToLeviCivita(OPMode oper );

  void neg();
  BraketOneTerm operator*(const string constval);
  BraketOneTerm operator*=(const string constval);
  BraketOneTerm operator*(const BraketOneTerm &L);
  BraketOneTerm operator*=(const BraketOneTerm &L);
  friend BraketOneTerm operator-(const BraketOneTerm &L);
  friend ostream& operator<<(ostream& out, const BraketOneTerm &L);

};


class Braket{
  vector< BraketOneTerm > expression;
  int flag;
  OPMode operation;
  unsigned int evaluated;
  /*  evaluated = 0 - > not yet evaluated
      evaluated = 1 - > evaluated creating deltas
      evaluated = 2 - > evaluated creating e_(...)... */


 public:
  Braket(void);
  Braket(const DList &d0);
  Braket(int id, string a, DList d0);
  Braket(int id, string a, DList d0, OPMode op);
  Braket(const Braket &L);
  Braket(int id, string a, const Braket &L, OPMode op);
  Braket(BraketOneTerm term);
  Braket(BraketOneTerm term, OPMode op);
  ~Braket();
  void clear();

  void expfromForm(vector<string> a);

  /* \brief Returns the current expression type, it also allows to set new expression type. Expression types: bra/ket/braket or none*/
  OPMode& Type();

  /* \brief Print the Braket expression mode, ie, the type of Braket: bra/ket/braket or none*/
  void mode();

  void evaluate(bool onlydeltas=true);
  void simplify();
  void rearrange();
  void checkDeltaIndex();
  void gindexsetnull();  
  void checkindex();
  void setON();
  void setOFF();
  int size();
  BraketOneTerm& Get(int pos);
  int& GetIndex(int pos);


  
  //OPERATORS

  Braket operator=(const Braket &L);
  Braket operator+(const Braket &L);
  Braket operator+=(const Braket &L);
  Braket operator-(const Braket &L);
  Braket operator-=(const Braket &L);
  Braket operator*(const Braket &L);
  Braket& operator*=(const Braket &L);
  Braket operator*(const string constval);
  Braket operator*=(const string constval);

  friend Braket operator-(const Braket &L);

  friend OPMode operator*(const OPMode a, const OPMode b);
  friend OPMode operator+(const OPMode a, const OPMode b);
  friend OPMode operator-(const OPMode a, const OPMode b);
  
  friend ostream& operator<<(ostream& out, const Braket &L);
  friend string& operator<<(string& out, const Braket &L);
  friend string& operator+(string& out, const Braket &L);
};



  ostream& operator<<(ostream& out, const OPMode &a);


}


#endif