QNLP::Arithmetic< SimulatorType > Class Template Reference

Class definition for bit-wise summation and subtraction of qubits. More...

#include <arithmetic.hpp>

Collaboration diagram for QNLP::Arithmetic< SimulatorType >:

Public Types
using	CST = const std::size_t

Static Public Member Functions
static void	sum_reg (SimulatorType &qSim, CST r1_min, CST r1_max, CST r2_min, CST r2_max)
	Implements |r1>|r2> -> |r1>|r1+r2>. Required bits to represent |r1+r2> should be available prior to calling, or overflow will occur. More...
static void	sub_reg (SimulatorType &qReg, const unsigned int r1_min, const unsigned int r1_max, const unsigned int r2_min, const unsigned int r2_max)
	Implements |r1>|r2> -> |r1>|r1-r2>. If r1 < r2 the state will underflow, with the subtraction continuing from |11..1>. More...

Detailed Description

template<class SimulatorType>
class QNLP::Arithmetic< SimulatorType >

Class definition for bit-wise summation and subtraction of qubits.

Template Parameters

SimulatorType

Definition at line 22 of file arithmetic.hpp.

Member Typedef Documentation

CST

template<class SimulatorType >

using QNLP::Arithmetic< SimulatorType >::CST = const std::size_t

Definition at line 24 of file arithmetic.hpp.

Member Function Documentation

sub_reg()

template<class SimulatorType >

static void QNLP::Arithmetic< SimulatorType >::sub_reg ( SimulatorType &  qReg, const unsigned int  r1_min, const unsigned int  r1_max, const unsigned int  r2_min, const unsigned int  r2_max  )

inlinestatic

Implements |r1>|r2> -> |r1>|r1-r2>. If r1 < r2 the state will underflow, with the subtraction continuing from |11..1>.

Parameters

qReg	The quantum register holding the bitstring to remain unmodified
r1_min	The lowest bounded r1 index to perform Fourier transform on.
r1_max	The highest bounded r1 index to perform Fourier transform on.
r2_min	The lowest bounded r2 index to perform Fourier transform on.
r2_max	The highest bounded r2 index to perform Fourier transform on.

Definition at line 64 of file arithmetic.hpp.

                                                                                                                                                            {
            std::size_t num_qubits_r1 = r1_max - r1_min;
            std::size_t num_qubits_r2 = r2_max - r2_min;

            assert( num_qubits_r1 == num_qubits_r2 );

            //Flip all states in r1
            for(int i = r1_min; i < r1_max; i++){
                qReg.applyGateX(i);
            }
            sum_reg(qReg, r1_min, r1_max, r2_min, r2_max);
            //Flip states to return the sum
            for(int i = r2_min; i < r2_max; i++){
                qReg.applyGateX(i);
            }    
            //Return all qubits in r1 to original state 
            for(int i = r1_min; i < r1_max; i++){
                qReg.applyGateX(i);
            }
        }

References QNLP::Arithmetic< SimulatorType >::sum_reg().

Referenced by TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

sum_reg()

template<class SimulatorType >

static void QNLP::Arithmetic< SimulatorType >::sum_reg ( SimulatorType &  qSim, CST  r1_min, CST  r1_max, CST  r2_min, CST  r2_max  )

inlinestatic

Implements |r1>|r2> -> |r1>|r1+r2>. Required bits to represent |r1+r2> should be available prior to calling, or overflow will occur.

Parameters

qReg	The quantum register holding the bitstrings r1,r2
r1_min	The lowest bounded r1 index to perform Fourier transform on.
r1_max	The highest bounded r1 index to perform Fourier transform on.
r2_min	The lowest bounded r2 index to perform Fourier transform on.
r2_max	The highest bounded r2 index to perform Fourier transform on.

Definition at line 34 of file arithmetic.hpp.

                                                                                                {
            std::size_t num_qubits_r1 = r1_max - r1_min;
            std::size_t num_qubits_r2 = r2_max - r2_min;

            assert( num_qubits_r1 == num_qubits_r2 );

            qSim.applyQFT(r2_min, r2_max);
            double theta = 0.0;

            //Targets
            for(int i = r2_max; i >= (int) r2_min; i--){
                //Controls
                for(int j = r1_max - (r2_max - i); j >= (int) r1_min; j--){
                    theta = 2.0*M_PI / (std::size_t) (1<<(1 + (i-j)));
                    qSim.applyGateCPhaseShift(theta, j, i);
                }
            }

            qSim.applyIQFT(r2_min, r2_max);
        }

Referenced by QNLP::Arithmetic< SimulatorType >::sub_reg(), and TEST_CASE().

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• /Users/mlxd/Desktop/intel-qnlp-rc2/modules/gate_ops/arithmetic/arithmetic.hpp