qggates.h

/***************************************************************************
 *   QGame++                                                               *
 *   =======                                                               *
 *   A Quantum Gate And Measurement Emulator.                              *
 *                                                                         *
 *   Copyright (C) 2003/04 by Manuel Nickschas                             *
 *   <qgame-devel@nickschas.de>                                            *
 *                                                                         *
 *   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.             *
 ***************************************************************************/

#ifndef _QGGATES_H_
#define _QGGATES_H_

#include "qgtypes.h"
#include "qgerror.h"

#include <vector>
#include <string>
#include <iostream>
#include <cmath>

namespace qgame {
  
  class QGate {

   public:
    virtual std::string dump() const;   
    virtual unsigned int numQb() = 0;   
    virtual void apply(QuSubReg &) = 0; 
  };

  class QMatrixGate : public QGate {
   protected:
    int numQubits;  
    int numAmps;    
    std::vector<std::vector<Complex> > matrix;  
    QMatrixGate() {} ;
   public:
    virtual unsigned int numQb();
    virtual void apply(QuSubReg &) throw(Error);
    
    std::string dump() const;
    QMatrixGate(std::vector<std::vector<Complex> >);  
  };
  
  std::ostream & operator<<(std::ostream &o, const QGate &);
  
  /****************************************************************************
   * Standard quantum gates
   ****************************************************************************/
  
  class QGateQNOT : public QMatrixGate {
   public:
    QGateQNOT();
    std::string dump() const;
  };
  
  class QGateCNOT : public QMatrixGate {
   public:
    QGateCNOT();
    std::string dump() const;
  };
  
  class QGateNAND : public QMatrixGate {
   public:
    QGateNAND();
    std::string dump() const;
  };
  
  class QGateSRN : public QMatrixGate {
   public:
    QGateSRN();
    std::string dump() const;
  };
  
  class QGateH2 : public QMatrixGate {
   public:
    QGateH2();
    std::string dump() const;
  };
  
  class QGateUTHETA : public QMatrixGate {
    double theta;
   public:
    QGateUTHETA(double theta); 
    std::string dump() const;
  };
  
  class QGateCPHASEOLD : public QMatrixGate {
    double alpha;
   public:
    QGateCPHASEOLD(double alpha); 
    std::string dump() const;
  };
  
  class QGateCPHASE : public QMatrixGate {
   double alpha;
   public:
    QGateCPHASE(double alpha); 
    std::string dump() const;
  };

  class QGateU2 : public QMatrixGate {
    double phi,theta,psi,alpha;
   public:
    QGateU2(double phi, double theta, double psi, double alpha); 
    std::string dump() const;
  };
  
  class QGateSWAP : public QMatrixGate {
   public:
    QGateSWAP();
    std::string dump() const;
  };
  
  class QOracle : public QMatrixGate {
    std::string truthtable;
   public:
    QOracle(const std::string &truthtable); 
    std::string dump() const;
  };

};

#endif

---