fork download
copy 
  1. #include <iostream>
  2. #include <complex>
  3. #include <cmath>
  4. #include <random>
  5.  
  6. #define M_PI           3.14159265358979323846
  7.  
  8. class QBit {
  9. private:
  10.     std::complex<double> _alpha{ 1, 0 };  // |0>
  11.     std::complex<double> _beta{ 0, 0 };   // |1>
  12.  
  13.     static std::default_random_engine generator;
  14.     static std::uniform_real_distribution<double> distribution;
  15.  
  16. public:
  17.     // H: Hadamard gate
  18.     void H() {
  19.         auto newAlpha = (_alpha + _beta) / std::sqrt(2.0);
  20.         auto newBeta = (_alpha - _beta) / std::sqrt(2.0);
  21.  
  22.         _alpha = newAlpha;
  23.         _beta = newBeta;
  24.     }
  25.  
  26.     // X: Pauli-X gate or NOT gate
  27.     void X() {
  28.         auto temp = _alpha;
  29.         _alpha = _beta;
  30.         _beta = temp;
  31.     }
  32.  
  33.     // Pauli-Y gate
  34.     void Y() {
  35.         auto newAlpha = std::complex<double>(0, 1) * _beta;
  36.         auto newBeta = -std::complex<double>(0, 1) * _alpha;
  37.  
  38.         _alpha = newAlpha;
  39.         _beta = newBeta;
  40.     }
  41.  
  42.     // Pauli-Z gate
  43.     void Z() {
  44.         _beta = -_beta;
  45.     }
  46.  
  47.     // S: Phase gate
  48.     void S() {
  49.         _beta = std::complex<double>(0, 1) * _beta;
  50.     }
  51.  
  52.     // T: π/8 gate or T gate
  53.     void T() {
  54.         _beta = std::exp(std::complex<double>(0, M_PI / 4.0)) * _beta;
  55.     }
  56.  
  57.     // Measurement and Collapse!
  58.     bool M() {
  59.         double probabilityZero = std::norm(_alpha);
  60.         double randomValue = distribution(generator);
  61.  
  62.         if (randomValue < probabilityZero) {
  63.             CollapseToZero();
  64.             return false;
  65.         }
  66.         else {
  67.             CollapseToOne();
  68.             return true;
  69.         }
  70.     }
  71.  
  72.     void CollapseToZero() {
  73.         _alpha = { 1, 0 };
  74.         _beta = { 0, 0 };
  75.     }
  76.  
  77.     void CollapseToOne() {
  78.         _alpha = { 0, 0 };
  79.         _beta = { 1, 0 };
  80.     }
  81.  
  82.     // SWAP: Swap gate
  83.     void Swap(QBit& otherQBit) {
  84.         auto tempAlpha = _alpha;
  85.         auto tempBeta = _beta;
  86.  
  87.         _alpha = otherQBit._alpha;
  88.         _beta = otherQBit._beta;
  89.  
  90.         otherQBit._alpha = tempAlpha;
  91.         otherQBit._beta = tempBeta;
  92.     }
  93.  
  94.     // CNOT: Controlled NOT gate or Controlled X gate
  95.     void CNot(QBit& control) {
  96.         if (std::norm(control._beta) > 0.5) { // Control qubit is more likely in |1> state
  97.             X();
  98.         }
  99.     }
  100.  
  101.     // CCNOT: Double-controlled NOT gate or Toffoli gate
  102.     void CCNot(QBit& control1, QBit& control2) {
  103.         double probabilityControl1One = std::norm(control1._beta);
  104.         double probabilityControl2One = std::norm(control2._beta);
  105.  
  106.         if (probabilityControl1One > 0.5 && probabilityControl2One > 0.5) {
  107.             X();
  108.         }
  109.     }
  110. };
  111.  
  112. std::default_random_engine QBit::generator;
  113. std::uniform_real_distribution<double> QBit::distribution(0.0, 1.0);
  114.  
  115. int main() {
  116.     for (int i = 0; i<10; i++)
  117.     {
  118.         QBit q1;
  119.         q1.H();
  120.         std::cout << q1.M() << std::endl;
  121.     }
  122.  
  123.     return 0;
  124. }
  125.  
Success #stdin #stdout 0.01s 5548KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
0
0
0
1
1
1
0
1
0
0
https://ideone.com/DWg4Ak
language:
C++14 (gcc 8.3)
created:
233 days ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!