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

#include <string>
#include <vector>

namespace qgame {

  struct Result {
    int misses;           
    double maxError;      
    double avgError;      
    double maxExpOracles; 
    double avgExpOracles; 
  };
  std::ostream & operator<<(std::ostream &, const Result &);
  
  struct Measurement {
    int qubit;    
    int result;   
    double prob;  
  };

  class QSys {
    QProgram *prg;
    int instrPnt;
    double prob;
  
    int numQubits;
    Qureg reg;
    std::string oracleTT;
    int oracleCount;
    std::vector<Measurement> measureHistory;
    std::vector<bool> execInstr;  // for branch handling

    std::vector<QSys*> exec() throw(Error); // internal exec without init
    void markBranch(bool branch); // set execInstr and instrPnt for appropriate branch
    void appendMeasurement(QubitList q, int outcome, double prob); // append result of measurement to hist
    
    friend std::ostream& operator<<(std::ostream &, const QSys &);
    
   public:
    QSys();
    ~QSys();
    void init(int numQubits, QProgram *prg, const std::string &oracleTT);
    QSys *clone(double priorProb); 
    static std::vector<QSys*> execute(int numQubits, QProgram *prg, const std::string &oracleTT) throw(Error);
    static Result testProgram(
                        int numQubits,                       
                        QProgram *prg,                       
                        const std::vector<TestCase> &cases,  
                        const QubitList &finalMeasure,       
                        double threshold                     
                  ) throw(Error); 
    Qureg  getReg();                  
    void   setReg(const Qureg &);     
    double getProb();                 
    void   setProb(double prob);      
    int    getOracleCount();          
    std::vector<Measurement> getMeasurementHistory();   
    void apply(QGate *, const QubitList &) throw(Error); 
    void apply(const QInstr &) throw(Error); 
  };
  
  std::ostream& operator<<(std::ostream &, const QSys &);
};

#endif

---