Gate.h

Go to the documentation of this file.

/*
Created on Fri Jun 26 14:13:26 2020
Copyright 2020 Peter Rakyta, Ph.D.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

@author: Peter Rakyta, Ph.D.
*/
#ifndef GATE_H
#define GATE_H

#include <vector>
#include "common.h"
#include "matrix.h"
#include "matrix_float.h"
#include "logging.h"
#include "matrix_real.h"
#include "matrix_real_float.h"
#include "matrix_any.h"
#include "matrix_real_any.h"
#include <utility>


typedef enum gate_type {GENERAL_OPERATION=1, 
                        CZ_OPERATION=4, 
                        CNOT_OPERATION=5, 
                        CH_OPERATION=6, 
                        U3_OPERATION=7, 
                        RY_OPERATION=8, 
                        RX_OPERATION=9, 
                        RZ_OPERATION=10, 
                        X_OPERATION=12, 
                        SX_OPERATION=13, 
                        CRY_OPERATION=14, 
                        SYC_OPERATION=15, 
                        BLOCK_OPERATION=16, 
                        ADAPTIVE_OPERATION=18, 
                        DECOMPOSITION_BASE_CLASS=19, 
                        SUB_MATRIX_DECOMPOSITION_CLASS=20, 
                        N_QUBIT_DECOMPOSITION_CLASS_BASE=21, 
                        N_QUBIT_DECOMPOSITION_CLASS=22, 
                        Y_OPERATION=23, 
                        Z_OPERATION=24, 
                        H_OPERATION=25, 
                        CROT_OPERATION=27,
                        R_OPERATION=28,
                        T_OPERATION=29,
                        TDG_OPERATION=30,
                        U1_OPERATION=31,
                        U2_OPERATION=32,
                        CR_OPERATION=33,
                        S_OPERATION=34,
                        SDG_OPERATION=35,
                        CU_OPERATION=36,
                        CP_OPERATION=38,
                        CRX_OPERATION=39,
                        CRZ_OPERATION=40,
                        CCX_OPERATION=41,
                        SWAP_OPERATION=42,
                        CSWAP_OPERATION=43,
                        RXX_OPERATION=44,
                        RYY_OPERATION=45,
                        RZZ_OPERATION=46,
                        SXDG_OPERATION=47} gate_type;



class Gate : public logging {


protected:

    std::string name;
    int qbit_num;
    gate_type type;
    int target_qbit;
    int control_qbit;
    std::vector<int> target_qbits;
    std::vector<int> control_qbits;
    int matrix_size;
    int parameter_num;
    int parameter_start_idx;
    std::vector<Gate*> parents;
    std::vector<Gate*> children;

private:

    Matrix matrix_alloc;
    Matrix_float matrix_alloc_float;
    bool matrix_alloc_float_valid;

public:

Gate();

virtual ~Gate();


Gate(int qbit_num_in);

Gate(int qbit_num_in, const std::vector<int>& target_qbits_in, const std::vector<int>& control_qbits_in = std::vector<int>());

virtual Matrix get_matrix( Matrix_real& parameters, int parallel  );

virtual Matrix get_matrix( Matrix_real& parameters );

virtual Matrix get_matrix();

virtual Matrix get_matrix( int parallel );

virtual Matrix_float get_matrix( Matrix_real_float& parameters, int parallel );

virtual void apply_to_list( std::vector<Matrix>& inputs, int parallel );


virtual void apply_to_list( Matrix_real& parameters_mtx, std::vector<Matrix>& inputs, int parallel );

virtual void apply_to_list( std::vector<Matrix_float>& inputs, int parallel );

virtual void apply_to_list( Matrix_real_float& parameters_mtx, std::vector<Matrix_float>& inputs, int parallel );

virtual void apply_to( Matrix& input, int parallel );

virtual void apply_to( Matrix_float& input, int parallel );

virtual void apply_to( Matrix_real& parameter_mtx, Matrix& input, int parallel );

virtual void apply_to( Matrix_real_float& parameter_mtx, Matrix_float& input, int parallel );

virtual void apply_to_inner( Matrix_real& parameter_mtx, const Matrix_real& precomputed_sincos, Matrix& input, int parallel );

virtual void apply_to_inner( Matrix_real_float& parameter_mtx, const Matrix_real_float& precomputed_sincos, Matrix_float& input, int parallel );

void apply_to( Matrix_any& input, int parallel );

void apply_to( Matrix_real_any& parameter_mtx, Matrix_any& input, int parallel );


virtual std::vector<Matrix> apply_derivate_to( Matrix_real& parameters_mtx_in, Matrix& input, int parallel );

virtual void apply_derivate_to( Matrix_real& parameters_mtx_in, Matrix& input, int parallel, std::vector<Matrix>& output );

virtual std::vector<Matrix_float> apply_derivate_to( Matrix_real_float& parameters_mtx_in, Matrix_float& input, int parallel );

virtual void apply_derivate_to( Matrix_real_float& parameters_mtx_in, Matrix_float& input, int parallel, std::vector<Matrix_float>& output );

virtual std::vector<Matrix> apply_to_combined( Matrix_real& parameters_mtx_in, Matrix& input, int parallel );

virtual void apply_to_combined( Matrix_real& parameters_mtx_in, Matrix& input, int parallel, std::vector<Matrix>& output );

virtual std::vector<Matrix_float> apply_to_combined( Matrix_real_float& parameters_mtx_in, Matrix_float& input, int parallel );

virtual void apply_to_combined( Matrix_real_float& parameters_mtx_in, Matrix_float& input, int parallel, std::vector<Matrix_float>& output );

virtual std::vector<Matrix> apply_to_combined_inner( Matrix_real& parameters_mtx_in, const Matrix_real& precomputed_sincos, Matrix& input, int parallel );

virtual void apply_to_combined_inner( Matrix_real& parameters_mtx_in, const Matrix_real& precomputed_sincos, Matrix& input, int parallel, std::vector<Matrix>& output );

virtual std::vector<Matrix_float> apply_to_combined_inner( Matrix_real_float& parameters_mtx_in, const Matrix_real_float& precomputed_sincos, Matrix_float& input, int parallel );

virtual void apply_to_combined_inner( Matrix_real_float& parameters_mtx_in, const Matrix_real_float& precomputed_sincos, Matrix_float& input, int parallel, std::vector<Matrix_float>& output );


virtual void apply_from_right( Matrix& input );

virtual void apply_from_right( Matrix_float& input );

virtual void apply_from_right( Matrix_real& parameter_mtx, Matrix& input );

virtual void apply_from_right( Matrix_real_float& parameter_mtx, Matrix_float& input );

virtual void apply_from_right_inner( Matrix_real& parameter_mtx, const Matrix_real& precomputed_sincos, Matrix& input );

virtual void apply_from_right_inner( Matrix_real_float& parameter_mtx, const Matrix_real_float& precomputed_sincos, Matrix_float& input );

Matrix_real compute_precomputed_sincos(const Matrix_real& parameters) const;

Matrix_real_float compute_precomputed_sincos(const Matrix_real_float& parameters) const;

void set_matrix( Matrix input );

void set_matrix( Matrix_float input );


void set_control_qbit(int control_qbit_in);

void set_target_qbit(int target_qbit_in);

void set_control_qbits(const std::vector<int>& control_qbits_in);

void set_target_qbits(const std::vector<int>& target_qbits_in);

virtual void set_qbit_num( int qbit_num_in );

virtual void reorder_qubits( std::vector<int> qbit_list );


int get_target_qbit();


int get_control_qbit();

std::vector<int> get_target_qbits() const;

std::vector<int> get_control_qbits() const;

virtual std::vector<int> get_involved_qubits(bool only_target=false);

void add_child( Gate* child );


void add_parent( Gate* parent );


void clear_children();


void clear_parents();

virtual int get_parameter_num();


gate_type get_type();

int get_qbit_num();


void set_parameter_start_idx(int start_idx);


void set_parents( std::vector<Gate*>& parents_ );


void set_children( std::vector<Gate*>& children_ );



std::vector<Gate*> get_parents();


std::vector<Gate*> get_children();


int get_parameter_start_idx();


std::string get_name();

virtual Gate* clone();

virtual Matrix gate_kernel(const Matrix_real& precomputed_sincos);
virtual Matrix_float gate_kernel(const Matrix_real_float& precomputed_sincos);
virtual Matrix inverse_gate_kernel(const Matrix_real& precomputed_sincos);
virtual Matrix_float inverse_gate_kernel(const Matrix_real_float& precomputed_sincos);
virtual Matrix derivative_kernel(const Matrix_real& precomputed_sincos, int param_idx);
virtual Matrix_float derivative_kernel(const Matrix_real_float& precomputed_sincos, int param_idx);
virtual void gate_kernel_to(const Matrix_real& precomputed_sincos, Matrix& output);
virtual void gate_kernel_to(const Matrix_real_float& precomputed_sincos, Matrix_float& output);
virtual void inverse_gate_kernel_to(const Matrix_real& precomputed_sincos, Matrix& output);
virtual void inverse_gate_kernel_to(const Matrix_real_float& precomputed_sincos, Matrix_float& output);
virtual void derivative_kernel_to(const Matrix_real& precomputed_sincos, int param_idx, Matrix& output);
virtual void derivative_kernel_to(const Matrix_real_float& precomputed_sincos, int param_idx, Matrix_float& output);
virtual void derivative_aux_kernel_to(const Matrix_real& precomputed_sincos, int param_idx, Matrix& output);
virtual void derivative_aux_kernel_to(const Matrix_real_float& precomputed_sincos, int param_idx, Matrix_float& output);
virtual Matrix derivative_aux_kernel(const Matrix_real& precomputed_sincos, int param_idx);
virtual Matrix_float derivative_aux_kernel(const Matrix_real_float& precomputed_sincos, int param_idx);

virtual std::vector<double> get_parameter_multipliers() const;

static Matrix calc_one_qubit_u3(double ThetaOver2 = 0.0, double Phi = 0.0, double Lambda = 0.0);
static Matrix_float calc_one_qubit_u3(float ThetaOver2, float Phi, float Lambda);

virtual Matrix_real extract_parameters( Matrix_real& parameters );

virtual Matrix_real_float extract_parameters( Matrix_real_float& parameters );


protected:
Matrix_real precompute_sincos(const Matrix_real& parameters) const;

Matrix_real_float precompute_sincos(const Matrix_real_float& parameters) const;

std::vector<Matrix> apply_derivative_to_precomputed(const Matrix_real& precomputed_sincos, Matrix& input, int parallel);

void apply_derivative_to_precomputed(const Matrix_real& precomputed_sincos, Matrix& input, int parallel, std::vector<Matrix>& output, size_t offset = 0, bool resize_output = true);

std::vector<Matrix_float> apply_derivative_to_precomputed(const Matrix_real_float& precomputed_sincos, Matrix_float& input, int parallel);

void apply_derivative_to_precomputed(const Matrix_real_float& precomputed_sincos, Matrix_float& input, int parallel, std::vector<Matrix_float>& output, size_t offset = 0, bool resize_output = true);

void apply_kernel_to( Matrix& u3_1qbit, Matrix& input, bool deriv=false, int parallel=0, const Matrix* alt_kernel=nullptr );

void apply_kernel_to( Matrix_float& u3_1qbit, Matrix_float& input, bool deriv=false, int parallel=0, const Matrix_float* alt_kernel=nullptr );



void apply_kernel_from_right( Matrix& u3_1qbit, Matrix& input, const Matrix* alt_kernel=nullptr );

void apply_kernel_from_right( Matrix_float& u3_1qbit, Matrix_float& input, const Matrix_float* alt_kernel=nullptr );


};

#endif //GATE