qggates.cpp

/***************************************************************************
 *   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.             *
 ***************************************************************************/

#include "qggates.h"
#include "qgtypes.h"

#include <sstream>

using namespace qgame;
using namespace std;

string QGate::dump() const {
  return "GENERIC QGATE";
}

ostream & qgame::operator<<(ostream &o, const QGate &g) {
  o << g.dump();
  return o;
}

unsigned int QMatrixGate::numQb() {
  return numQubits;
}

void QMatrixGate::apply(QuSubReg &reg) throw(Error) {
  vector<Complex> res;
  if(numQubits!=reg.numQb()) throw(E_MISMATCH);
  for(int row = 0; row<numAmps; row++) { //cerr << "\n ** ";
    Complex dum(0,0);
    for(int col = 0; col<numAmps; col++) { //cerr << matrix[row][col] << " ";
      dum+=matrix[row][col]*reg[col];
    }
    res.push_back(dum);
  }  // TODO: optimize!
  for(int row = 0; row<numAmps; row++) {
    reg[row]=res[row];
  }
}

QMatrixGate::QMatrixGate(vector<vector<Complex> > m) {
  numAmps = m.size();
  numQubits = (int)(log((double)numAmps)/log(2.)+.5);
  matrix = m;
}

string QMatrixGate::dump() const {
  return "MATRIX-GATE";
}

/***************************************************************************/

QGateQNOT::QGateQNOT() {
  numQubits = 1;
  numAmps = 2;
  vector<Complex> row0,row1;
  row0.push_back(0); row0.push_back(1);
  row1.push_back(1); row1.push_back(0);
  matrix.push_back(row0);
  matrix.push_back(row1);
}

string QGateQNOT::dump() const {
  return "QNOT";
}

QGateCNOT::QGateCNOT() {
  numQubits = 2;
  numAmps = 4;
  vector<Complex> row(4,Complex(0,0));
  matrix.insert(matrix.begin(),4,row);
  matrix[0][0]=matrix[1][1]=matrix[2][3]=matrix[3][2]=Complex(1,0);
}

string QGateCNOT::dump() const {
  return "CNOT";
}

QGateNAND::QGateNAND() {
  numQubits = 3;
  numAmps = 8;
  vector<Complex> row(8,Complex(0,0));
  matrix.insert(matrix.begin(),8,row);
  matrix[1][0]=matrix[0][1]=matrix[2][3]=matrix[3][2]=Complex(1,0);
  matrix[4][5]=matrix[5][4]=matrix[6][7]=matrix[7][6]=Complex(1,0);
}

string QGateNAND::dump() const {
  return "NAND";
}

QGateSRN::QGateSRN() {
  numQubits = 1;
  numAmps = 2;
  vector<Complex> row(2,Complex(1./sqrt(2.),0));
  matrix.insert(matrix.begin(),2,row);
  matrix[0][1]=Complex(-1./sqrt(2.),0);
}

string QGateSRN::dump() const {
  return "SRN";
}

QGateH2::QGateH2() {
  numQubits = 1;
  numAmps = 2;
  vector<Complex> row(2,Complex(1./sqrt(2.),0));
  matrix.insert(matrix.begin(),2,row);
  matrix[1][1]=Complex(-1./sqrt(2.),0);
}

string QGateH2::dump() const {
  return "HADAMARD";
}

QGateUTHETA::QGateUTHETA(double t) {
  theta = t;
  numQubits = 1;
  numAmps = 2;
  vector<Complex> row(2,Complex(cos(t),0));
  matrix.insert(matrix.begin(),2,row);
  matrix[0][1]=Complex(sin(t),0);
  matrix[1][0]=Complex(-sin(t),0);
}

string QGateUTHETA::dump() const {
  ostringstream ss;
  ss << "U-THETA [theta="<<theta<<"]";
  return ss.str();
}

QGateCPHASEOLD::QGateCPHASEOLD(double a) {
  alpha = a;
  numQubits = 2;
  numAmps = 4;
  vector<Complex> row(4,Complex(0,0));
  matrix.insert(matrix.begin(),4,row);
  matrix[0][0]=matrix[1][1]=Complex(1,0);
  matrix[2][3]=Complex(cos(alpha),sin(alpha));
  matrix[3][2]=Complex(cos(-alpha),sin(-alpha));
}

string QGateCPHASEOLD::dump() const {
  ostringstream ss;
  ss << "CPHASE-OLD [alpha="<<alpha<<"]"; 
  return ss.str();
}

QGateCPHASE::QGateCPHASE(double a) {
  alpha = a;
  numQubits = 2;
  numAmps = 4;
  vector<Complex> row(4,Complex(0,0));
  matrix.insert(matrix.begin(),4,row);
  matrix[0][0]=matrix[1][1]=matrix[2][2]=Complex(1,0);
  matrix[3][3]=Complex(cos(alpha),sin(alpha));
}

string QGateCPHASE::dump() const {
  ostringstream ss;
  ss << "CPHASE [alpha="<<alpha<<"]";
  return ss.str();
}

QGateU2::QGateU2(double ph,double t,double ps,double a) {
  phi = ph; theta = t; psi = ps; alpha = a;
  numQubits = 1;
  numAmps = 2;
  vector<Complex> row(2,Complex(0,0));
  matrix.insert(matrix.begin(),2,row);
  matrix[0][0]=Complex(cos(-phi-psi+alpha)*cos( theta),sin(-phi-psi+alpha)*cos( theta));
  matrix[0][1]=Complex(cos(-phi+psi+alpha)*sin(-theta),sin(-phi+psi+alpha)*sin(-theta));
  matrix[1][0]=Complex(cos( phi-psi+alpha)*sin( theta),sin( phi-psi+alpha)*sin( theta));
  matrix[1][1]=Complex(cos( phi+psi+alpha)*cos( theta),sin( phi+psi+alpha)*cos( theta));
}

string QGateU2::dump() const {
  ostringstream ss;
  ss << "U2 [phi="<<phi<<" theta="<<theta<<" psi="<<psi<<" alpha="<<alpha<<"]"; 
  return ss.str();
}

QGateSWAP::QGateSWAP() : QMatrixGate() {
  numQubits = 2;
  numAmps = 4;
  vector<Complex> row(4,Complex(0,0));
  matrix.insert(matrix.begin(),4,row);
  matrix[0][0]=matrix[2][1]=matrix[1][2]=matrix[3][3]=Complex(1,0);
}

string QGateSWAP::dump() const {
  return "SWAP";
}

QOracle::QOracle(const string &tt) : QMatrixGate() {
  truthtable = tt;
  numAmps = tt.length()*2;
  numQubits = (int)(log((double)numAmps)/log(2.)+.5);
  vector<Complex> row(numAmps,Complex(0,0));
  matrix.insert(matrix.begin(),numAmps,row);
  for(int i=0; i<tt.length();i++) {
    if(tt[i]=='0') {
      matrix[i*2][i*2]=1;matrix[i*2+1][i*2+1]=1;
    } else if(tt[i]=='1') {
      matrix[i*2][i*2+1]=1;matrix[i*2+1][i*2]=1;
    } else throw Error(E_SYNTAX);
  }
}

string QOracle::dump() const {
  return "ORACLE [tt="+truthtable+"]";
}

---