qgprog.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 "qgprog.h"
#include "qggates.h"
#include "qgtypes.h"
#include "qgerror.h"

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

using namespace std;
using namespace qgame;

ostream & qgame::operator<<(ostream &o, const QInstr &i) {
  o << "(";
  if(i.gate) o << *i.gate << " ";
  else {
    switch(i.type) {
      case ORACLE: o << "ORACLE [tt=<UNKNOWN>]"; break;
      case LIMITED_ORACLE: o << "LIMITED-ORACLE [l=" << i.extra << " tt=<UNKNOWN>]"; break;
      case END: o << "END"; break;
      case HALT: o << "HALT"; break;
      case MEASURE: o << "MEASURE"; break;
    
      default: o << "<UNKNOWN> "; break;
    }
  }
  o << i.qubits << ")";
  return o;
}

QProgram::QProgram() {
  instrPnt = 0;
}

QProgram::~QProgram() {
  for(int i = 0; i<instr.size(); i++) {
    delete instr[i];
  }
}

ostream & qgame::operator<<(ostream &o, const QProgram &p) {
  if(p.instr.size()==0) {
    o << "<EMPTY>" << endl;
    return o;
  }
  for(int i=0; i<p.instr.size(); i++) {
    o << "***";
    o << *p.instr[i] << endl;
  }
  return o;
}

QInstr * QProgram::operator[](unsigned int index) throw(Error) {
  if(index>=instr.size()) throw E_OUTOFBOUNDS;
  return instr[index];
}

unsigned int QProgram::length() const {
  return instr.size();
}

QProgramSettings QProgram::read(istream &is) throw(Error) {
  const int bufsize = 2048;
  char buf[bufsize];
  QProgramSettings settings;
  //ifstream fin;
  //fin.open(fname.c_str(),ios::in);
  //if(!fin) throw(Error(E_IO));
  //while(is.getline(buf,bufsize)) {
  //  if(buf[0] == ':') parseSetting(settings, buf);
  //  else addInstruction(buf);
  //}
  //fin.close();
  char c;
  string instr;
  bool issetting = false;
  int depth = 0;
  while((c = is.get())!=EOF) {
    if(c != '\n') instr+=c;
    else if(is.peek() == '#') {
      while(is.peek() != '\n') is.get();
    } 
    if(c == ':') {
      issetting = true;
    } else {
      if(!issetting) {
        if(c == '(') {
          if(depth == 0) instr = "(";  // ignore whitespace
          depth++;
        } else if(c == ')') {
          depth--;
          if(depth < 0) throw Error(E_SYNTAX);
          if(depth == 0) {
            addInstruction(instr);
            instr = "";
          } else {
            while(is.peek() == ' ' || is.peek() == '\n') is.get();
          }
        }
      } else {
        if(c == '\n') {
          parseSetting(settings, instr);
          instr = "";
          issetting = false;
        }
      }
    }
  }
  return settings;
}

void QProgram::parseSetting(QProgramSettings &set, const string &line) throw(Error) {
  istringstream ss(line);
  char c = ss.get();
  if(c != ':') throw Error(E_SYNTAX);
  string param;
  ss >> param;
  if(param == "num-qubits") {
    ss >> set.numQb;
  } else if(param == "threshold") {
    ss >> set.threshold;
  } else if(param == "cases") {
    string str;
    while(ss >> str) {
      TestCase tc(str);
      if(tc.desiredRes<0) throw Error(E_SYNTAX);
      set.cases.push_back(tc);
      if(ss.peek() == EOF) break;
    }
  } else if(param == "final-measurement-qubits") {
    set.finalQb = getQubits(0, ss);
  }
  
  if(ss.get() != EOF) throw Error(E_SYNTAX);
}

// this method parses the QGAME syntax as defined in Lee's book.
QInstr * QProgram::parseLine(const string &line) throw(Error) {
  QInstr *inst = new QInstr;
  istringstream ss(line);
  char c = ss.get();
  if(c == '#' || c == ':' || c == EOF) {
    inst->gate = NULL;
    inst->type = COMMENT;
    return inst;
  }
  if(c !='(') throw Error(E_SYNTAX);
  string cmd;
  ss >> cmd;
  if(cmd == "CNOT") {
    inst->qubits = getQubits(2,ss);
    inst->type = CNOT;
    inst->gate = new QGateCNOT;
  } else if(cmd == "QNOT") {
    inst->qubits = getQubits(1,ss);
    inst->type = QNOT;
    inst->gate = new QGateQNOT;
  } else if(cmd == "SRN") {
    inst->qubits = getQubits(1,ss);
    inst->type = SRN;
    inst->gate = new QGateSRN;
  } else if(cmd == "NAND") {
    inst->qubits = getQubits(3,ss);
    inst->type = NAND;
    inst->gate = new QGateNAND;
  } else if(cmd == "HADAMARD") {
    inst->qubits = getQubits(1,ss);
    inst->type = HADAMARD;
    inst->gate = new QGateH2;
  } else if(cmd == "U-THETA") {
    inst->qubits = getQubits(1,ss);
    double theta;
    ss >> theta;
    inst->type = U_THETA;
    inst->gate = new QGateUTHETA(theta);
  } else if(cmd == "CPHASE-OLD") {
    inst->qubits = getQubits(2,ss);
    double alpha;
    ss >> alpha;
    inst->type = CPHASE_OLD;
    inst->gate = new QGateCPHASEOLD(alpha);
  } else if(cmd == "CPHASE") {
    inst->qubits = getQubits(2,ss);
    double alpha;
    ss >> alpha;
    inst->type = CPHASE;
    inst->gate = new QGateCPHASE(alpha);
  } else if(cmd == "U2") {
    inst->qubits = getQubits(1,ss);
    double phi,theta,psi,alpha;
    ss >> phi >> theta >> psi >> alpha;
    inst->type = U2;
    inst->gate = new QGateU2(phi,theta,psi,alpha);
  } else if(cmd == "SWAP") {
    inst->qubits = getQubits(2,ss);
    inst->type = SWAP;
    inst->gate = new QGateSWAP;
  } else if(cmd == "ORACLE") {
    while(ss.peek() == ' ') ss.get();
    if(ss.peek() == '(') {  // oracle-tt given
      ss.get();
      string tt; char c;
      while((c = ss.get()) != ')') {
        if(c == ' ') continue;
        if(c!='0' && c!='1') throw Error(E_SYNTAX);
        tt+=c;
      }
      cerr << tt;
      inst->gate = new QOracle(tt);
      inst->flag = false;
    } else { 
      string dum;
      ss >> dum; // "ORACLE-TT"
      if(dum == "ORACLE-TT") inst->flag = true;
      else throw Error(E_SYNTAX);
    }
    inst->qubits = getQubits(-1,ss);
    inst->type = ORACLE;
  } else if(cmd == "LIMITED-ORACLE") {
    ss >> inst->extra;  // limit
    while(ss.peek() == ' ') ss.get();
    if(ss.peek() == '(') {  // oracle-tt given
      ss.get();
      string tt; char c;
      while((c = ss.get()) != ')') {
        if(c == ' ') continue;
        if(c!='0' && c!='1') throw Error(E_SYNTAX);
        tt+=c;
      }
      cerr << tt;
      inst->gate = new QOracle(tt);
      inst->flag = false;
    } else { 
      string dum;
      ss >> dum; // "ORACLE-TT"
      if(dum == "ORACLE-TT") inst->flag = true;
      else throw Error(E_SYNTAX);
    }
    inst->qubits = getQubits(-1,ss);
    inst->type = LIMITED_ORACLE;
  } else if(cmd == "MATRIX-GATE") {
    while(ss.peek() == ' ') ss.get();
    vector<vector<Complex> > m;
    int n = 0; int rows = 0;
    if(ss.get() != '#' || ss.get() != '2' || ss.get() != 'A' || ss.get() != '(')
      throw Error(E_SYNTAX);
    // read a matrix line
    for(;;rows++) {
      if(ss.peek() == ')') break;
      if(ss.get() != '(') throw Error(E_SYNTAX);
      vector<Complex> r;
      int cols = 0;
      for(;;cols++) {
        if(ss.peek() == ')' || ss.peek() == EOF) break;
        double entry;  // we don't support reading complex numbers at the moment!
        ss >> entry;
        r.push_back(entry);
      }
      ss.get();
      if(!n) n = cols;
      if(cols != n) { throw Error(E_SYNTAX); }
      m.push_back(r);
    }
    ss.get();
    if(rows != n) throw Error(E_SYNTAX);
    QubitList q;
    int numqb = (int)(log((double)n)/log(2.)+.5);
    for(int i=0; i<numqb; i++) q.append(i);
    inst->qubits = q;
    inst->type = MATRIX_GATE;
    inst->gate = new QMatrixGate(m);
    return inst;
  } else if(cmd == "MEASURE") {
    inst->qubits = getQubits(1,ss);
    inst->type = MEASURE;
  } else if(cmd == "END)") {
    inst->type = END;
    return inst;
  } else if(cmd == "HALT)") {
    inst->type = HALT;
    return inst;
  } else if(cmd == "PRINTAMPS)") {
    inst->type = PRINTAMPS;
    return inst;
  }   
  
  if(ss.get()!=')') throw Error(E_SYNTAX);
  return inst;
}

/* Read the specified number of qubits from the given stream. */
QubitList QProgram::getQubits(int num, istringstream &ss) throw(Error) {
  vector<int> l;
  QubitList res;
  int n;
  if(num>0) {
    for(int i=0; i<num; i++) {
      ss >> n;
      l.push_back(n);
    }
  } else {
    while(ss.peek() != ')' && ss.peek() != EOF && ss >> n) l.push_back(n);
  }
  for(int i=l.size()-1; i>=0; i--) {
    res.append(l[i]);
  }
  return res;  
}

bool QProgram::addInstruction(const string &line) throw(Error) {
  QInstr *i = parseLine(line);
  return addInstruction(i);
}

bool QProgram::addInstruction(QInstr *i) throw(Error) {
  if(i->type != COMMENT) instr.push_back(i);
  return true;
}

void QProgram::installOracle(const string &tt) {
  if(tt == "") return;
  for(int i=0; i<instr.size(); i++) {
    if(instr[i]->type != ORACLE && instr[i]->type != LIMITED_ORACLE) continue;
    if(!instr[i]->flag) continue;  // fixed TT
    delete instr[i]->gate;
    instr[i]->gate = new QOracle(tt);
  }
}

---