    Next: Sample Output Up: Code for my Simulation Previous: util.C   Contents

## qubit.C

Below is the much simpler code for a single qubit. You may find it entertaining and educational to write a simple driver program for this class to toy with a single qubit.

```#include <iostream>
#include <math.h>
#include <stdlib.h>
#include "complex.h"

using namespace std;

class Qubit {
public:
Qubit();            //Default constructor.
virtual ~Qubit();           //Default destructor.
int Measure();      //Returns zero_state = 0 or one_state = 1 in accordance
//with the probabilities of zero_state and one_state.
void Dump() const;        //Prints our zero_state, and one_state, without
//disturbing anything, this operation has no physical
//realization, it is only for information and debugging.
//It should never be used in an algorithm for
//information.
void SetState(const Complex& zero_prob, const Complex& one_prob);
// Takes two complex numbers and sets the states to
//those values.
void SetAverage();  //Sets the state to 2^(1/2) zero_state, 2^(1/2)
//one_state.  No imaginary/phase component.
double MCC(int state) const;  //Multiply the zero or one state by its complex
//conjugate, and return the value.  This value
//will always be a real number, with no imaginary
//component.

private:
Complex zero_state;
//The probability of finding the Qubit in the zero or all imaginary
//state.  I currently use only the real portion.

Complex one_state;
//The probability of finding the Qubit in the one or all real state.
//I currently use only the real portion.

//|zero_state|^2 + |one_state|^2 should always be 1.
//This notation means z_s * ComplexConjugate(z_s) + o_s *
//ComplexConjugate(o_s) = 1.
};

//Qubit constructor, initially sets things in the zero state.
Qubit::Qubit() {
zero_state = Complex(1,0);
one_state = Complex(0,0);
srand(time(NULL));
}

//Returns <state>_state * ComplexConjugate(<state>_state).
double Qubit::MCC(int state) const {
if (state == 0) {
return (pow(zero_state.Real(), 2) + pow(zero_state.Imaginary(), 2));
} else {
return (pow(one_state.Real(), 2) + pow(one_state.Imaginary(), 2));
}
}

//Measurement operator.  Destructively collapses superpositions.
int Qubit::Measure() {
double rand1 = rand()/(double)RAND_MAX;

//This assumes that the sum of the squares of the amplitudes are = 1
if (MCC(0) > rand1) {
zero_state.Set(1,0);
one_state.Set(0,0);
return 0;
} else {
zero_state.Set(0,0);
one_state.Set(1,0);
return 1;
}
}

//Outputs state info for our qubit.  For debugging purposes.
void Qubit::Dump() const{
cout << "Amplitude of the zero state is "
<< zero_state.Real() << " +i" << zero_state.Imaginary() << endl
<< flush;
cout << "Amplitude of the one state is "
<< one_state.Real() << " +i" << one_state.Imaginary() << endl
<< flush;
}

//Sets the zero and one states to arbitrary amplitudes.  Outputs
//an error message if the two values MCC'ed != 1 + 0i.
void Qubit::SetState(const Complex& zero_prob, const Complex& one_prob) {
zero_state = zero_prob;
one_state = one_prob;
//Determine if |zero_state|^2 + |one_state|^2 == 1, if not we
//are not in a valid state.
double probab;
probab = MCC(0) + MCC(1);
if (fabs(probab - 1) > pow(10, -10)) {
//This funny expression
//allows us some rounding errors.
cout << "Warning, total probability for in SetState is different from 1." << endl << flush;
}
}

//Sets the qubit 1/2 way between the 0 state and the 1 state.  No phase.
void Qubit::SetAverage() {
zero_state.Set(pow(2, -.5), 0);
one_state.Set(pow(2, -.5), 0);
}
```    Next: Sample Output Up: Code for my Simulation Previous: util.C   Contents
Matthew Hayward - Quantum Computing and Shor's Algorithm GitHub Repository