hamming.hpp

Go to the documentation of this file.

#ifndef QNLP_HAMMING_ROTY
#define QNLP_HAMMING_ROTY

#include <cassert>
#include <utility>
#include <memory>
#include <cmath>
#include<vector>
#include<complex>

namespace QNLP{
    template <class SimulatorType>
    class HammingDistance{
        private:
            //Take the 2x2 matrix type from the template SimulatorType
            using Mat2x2Type = decltype(std::declval<SimulatorType>().getGateX());

            std::size_t len_bin_pattern;

        public:
            HammingDistance() = delete;

            HammingDistance(const std::size_t len_bin_pattern_){
                len_bin_pattern = len_bin_pattern_;
            };

            ~HammingDistance(){
            };

            static void computeHammingDistanceRotY(SimulatorType& qSim, 
                    const std::vector<std::size_t>& reg_memory,
                    const std::vector<std::size_t>& reg_auxiliary, 
                    std::size_t len_bin_pattern){
                
                double theta = M_PI / (double) len_bin_pattern; 
                auto Ry = qSim.getGateI();

                Ry(0,0) = std::complex<double>( cos(theta/2), 0.);
                Ry(0,1) = std::complex<double>(-sin(theta/2), 0.);
                Ry(1,0) = std::complex<double>( sin(theta/2), 0.);
                Ry(1,1) = std::complex<double>( cos(theta/2), 0.);

                qSim.addUToCache("RY", Ry);

                std::size_t len_reg_auxiliary;
                len_reg_auxiliary = reg_auxiliary.size();

                // Require length of auxiliary register to have n+2 qubits
                assert(reg_memory.size() + 1 < len_reg_auxiliary);

                for(std::size_t i = 0; i < len_bin_pattern; i++){
                    qSim.applyGateNCU(Ry, std::vector<std::size_t> {reg_auxiliary[i], reg_memory[i]}, reg_auxiliary[len_reg_auxiliary-2], "RY");
                    qSim.applyGateX(reg_memory[i]);
                    qSim.applyGateX(reg_auxiliary[i]);
                    qSim.applyGateNCU(Ry, std::vector<std::size_t> {reg_auxiliary[i], reg_memory[i]}, reg_auxiliary[len_reg_auxiliary-2], "RY");
                    qSim.applyGateX(reg_memory[i]);
                    qSim.applyGateX(reg_auxiliary[i]);
                }
            }

            static void computeHammingDistanceOverwriteAux(SimulatorType& qSim, 
                    const std::vector<std::size_t>& reg_memory,
                    const std::vector<std::size_t>& reg_auxiliary){
                
                // Require length of auxiliary register to have n+2 qubits
                assert(reg_memory.size() + 1 < reg_auxiliary.size());

                for(std::size_t i = 0; i < reg_memory.size(); i++){
                    qSim.applyGateX(reg_auxiliary[i]);
                    qSim.applyGateCCX(reg_memory[i], reg_auxiliary[i], *(reg_auxiliary.end()-2) );
                    qSim.applyGateX(reg_auxiliary[i]);
                    qSim.applyGateCSwap(reg_memory[i], reg_auxiliary[i], *(reg_auxiliary.end()-2) );
                }
            }


    };

};
#endif