qgtypes.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 _QGTYPES_H_
#define _QGTYPES_H_

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

#include "qgerror.h"

/***************************************************************************
 * Basic types for QGame++.
 ***************************************************************************/
 
namespace qgame {

  class Complex {
    double re,im;
    friend double sqabs(const Complex&);
    friend std::ostream& operator<<(std::ostream &, const Complex &);
 
   public:
    Complex(double re = 0, double im = 0);  
    double Re();        
    double Im();        
    double sqabs();     
    Complex operator+(const Complex&);  
    Complex operator-(const Complex&);  
    Complex operator*(const Complex&);  
    Complex operator+=(const Complex&); 
    Complex operator*=(const Complex&); 
  };
  std::ostream& operator<<(std::ostream &, const Complex &);
  double sqabs(const Complex&);   
  class QubitList {
    std::vector<int> qbl;
    friend std::ostream & operator<<(std::ostream &, const QubitList &);
    
   public:
    unsigned int size() const; 
    void append(int qbnum);    
    int operator[](const unsigned int) const throw(Error); 
  };
  std::ostream & operator<<(std::ostream &, const QubitList &);
  
  class QuSubReg {
    int num;
    std::vector<Complex*> sub;
    friend class Qureg;
    
   public:
    QuSubReg(int numQb); 
    ~QuSubReg();
    
    unsigned int numQb() const; 
    unsigned int numAmps() const; 
    Complex& operator[](const unsigned int) throw(Error); 
  };
  
  class Qureg {
    int num;
    std::vector<Complex> amp;
    
    friend class QuSubReg;
    friend std::ostream& operator<<(std::ostream &, Qureg);
   public:
    Qureg(int size = 0); 
    unsigned int size() const; 
    std::vector<QuSubReg> getSubRegs(const QubitList &qubits);
    std::vector<double> getProbabilities(const QubitList &qubits); 
    void collapse(const QubitList &qubits, int value);
    void normalize();     
    Complex & operator[](const unsigned int) throw(Error); 
  };
  std::ostream& operator<<(std::ostream &, Qureg);

  struct TestCase {
    std::string oracleTT; 
    int desiredRes;       
    TestCase(const std::string &tt, int res) { oracleTT = tt; desiredRes = res; }
    TestCase(const std::string &casestr); 
  };
};

#endif

---