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 "logging.h"
#include "matrix_real.h"


typedef enum gate_type {GENERAL_OPERATION=1, 
                        UN_OPERATION=2, 
                        ON_OPERATION=3, 
                        CZ_OPERATION=4, 
                        CNOT_OPERATION=5, 
                        CH_OPERATION=6, 
                        U3_OPERATION=7, 
                        RY_OPERATION=8, 
                        RX_OPERATION=9, 
                        RZ_OPERATION=10, 
                        RZ_P_OPERATION=11, 
                        X_OPERATION=12, 
                        SX_OPERATION=13, 
                        CRY_OPERATION=14, 
                        SYC_OPERATION=15, 
                        BLOCK_OPERATION=16, 
                        COMPOSITE_OPERATION=17, 
                        ADAPTIVE_OPERATION=18, 
                        DECOMPOSITION_BASE_CLASS=19, 
                        SUB_MATRIX_DECOMPOSITION_CLASS=10, 
                        N_QUBIT_DECOMPOSITION_CLASS_BASE=21, 
                        N_QUBIT_DECOMPOSITION_CLASS=22, 
                        Y_OPERATION=23, 
                        Z_OPERATION=24, 
                        H_OPERATION=25, 
                        CZ_NU_OPERATION=26,
                        CROT_OPERATION=27,
                        R_OPERATION=28,
                        T_OPERATION=29,
                        TDG_OPERATION=30,
                        U1_OPERATION=31,
                        U2_OPERATION=32,
                        CR_OPERATION=33,
                        CUSTOM_KERNEL_1QUBIT_GATE_OPERATION=34} gate_type;



class Gate : public logging {


protected:

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

private:

    Matrix matrix_alloc;

public:

Gate();

virtual ~Gate();


Gate(int qbit_num_in);

virtual Matrix get_matrix();

virtual Matrix get_matrix(int parallel);


virtual Matrix get_matrix( Matrix_real& parameters  );


virtual Matrix get_matrix( Matrix_real& 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( Matrix& input, int parallel );

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


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


virtual void apply_from_right( Matrix& input );

void set_matrix( Matrix input );


void set_control_qbit(int control_qbit_in);

void set_target_qbit(int target_qbit_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();

virtual std::vector<int> get_involved_qubits();


void add_child( Gate* child );


void add_parent( Gate* parent );


void clear_children();


void clear_parents();

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 calc_one_qubit_u3(double Theta, double Phi, double Lambda );

virtual Matrix calc_one_qubit_u3( );

virtual void parameters_for_calc_one_qubit(double& ThetaOver2, double& Phi, double& Lambda);

virtual Matrix_real extract_parameters( Matrix_real& parameters );




protected:
void apply_kernel_to( Matrix& u3_1qbit, Matrix& input, bool deriv=false, int parallel=0 );



void apply_kernel_from_right( Matrix& u3_1qbit, Matrix& input );


};

#endif //GATE