Operation_block (copy).cpp

Go to the documentation of this file.

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

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see http://www.gnu.org/licenses/.

@author: Peter Rakyta, Ph.D.
*/
#include "qgd/CNOT.h"
#include "qgd/U3.h"
#include "qgd/Operation_block.h"

using namespace std;

Operation_block::Operation_block() : Operation() {

    // A string describing the type of the operation
    type = BLOCK_OPERATION;
    // number of operation layers
    layer_num = 0;
}



Operation_block::Operation_block(int qbit_num_in) : Operation(qbit_num_in) {

    // A string describing the type of the operation
    type = BLOCK_OPERATION;
    // number of operation layers
    layer_num = 0;
}


Operation_block::~Operation_block() {

    release_operations();
}

void Operation_block::release_operations() {

    //free the alloctaed memory of the stored operations
    for(std::vector<Operation*>::iterator it = operations.begin(); it != operations.end(); ++it) {

        Operation* operation = *it;

        if (operation->get_type() == CNOT_OPERATION) {
            CNOT* cnot_operation = static_cast<CNOT*>(operation);
            delete cnot_operation;
        }
        else if (operation->get_type() == U3_OPERATION) {

            U3* u3_operation = static_cast<U3*>(operation);
            delete u3_operation;

        }
        else if (operation->get_type() == BLOCK_OPERATION) {

            Operation_block* block_operation = static_cast<Operation_block*>(operation);
            delete block_operation;

        }
        else if (operation->get_type() == GENERAL_OPERATION) {
            delete operation;
        }
    }

    operations.clear();

}


Matrix Operation_block::get_matrix( const double* parameters  ) {

    // get the matrices of the operations grouped in the block
    vector<Matrix> operation_mtxs = get_matrices( parameters );

    // calculate the product of the matrices
    Matrix block_matrix = reduce_zgemm( operation_mtxs );

    operation_mtxs.clear();

    return block_matrix;
}


QGD_Complex16* Operation_block::matrix( const double* parameters  ) {

    // get the matrices of the operations grouped in the block
    vector<Matrix> operation_mtxs = get_matrices( parameters );

    // calculate the product of the matrices
    Matrix block_matrix = reduce_zgemm( operation_mtxs );

    operation_mtxs.clear();

    block_matrix.set_owner(false);
    return block_matrix.get_data();
}



int Operation_block::matrix( const double* parameters, QGD_Complex16* block_mtx  ) {

    // get the matrices of the operations grouped in the block
    vector<Matrix> operation_mtxs = get_matrices( parameters );

    // calculate the product of the matrices
    Matrix block_matrix = reduce_zgemm( operation_mtxs );

    operation_mtxs.clear();

    memcpy(block_mtx, block_matrix.get_data(), block_matrix.size()*sizeof(QGD_Complex16));


    return 0;



}




std::vector<Matrix> Operation_block::get_matrices( const double* parameters ) {

    std::vector<Matrix> matrices;
    Matrix operation_mtx;

    for(std::vector<Operation*>::iterator it = operations.begin(); it != operations.end(); ++it) {

        Operation* operation = *it;


        if (operation->get_type() == CNOT_OPERATION) {
            CNOT* cnot_operation = static_cast<CNOT*>(operation);
            operation_mtx = cnot_operation->get_matrix();

        }
        else if (operation->get_type() == U3_OPERATION) {

            U3* u3_operation = static_cast<U3*>(operation);

            if (u3_operation->get_parameter_num() == 1 ) {
                operation_mtx = u3_operation->get_matrix( parameters );
                parameters = parameters + 1;
            }
            else if (u3_operation->get_parameter_num() == 2 ) {
                operation_mtx = u3_operation->get_matrix( parameters );
                parameters = parameters + 2;
            }
            else if (u3_operation->get_parameter_num() == 3 ) {
                operation_mtx = u3_operation->get_matrix( parameters );
                parameters = parameters + 3;
            }
            else {
                printf("The U3 operation has wrong number of parameters");
                throw "The U3 operation has wrong number of parameters";
            }

        }
        else if (operation->get_type() == GENERAL_OPERATION) {
            operation_mtx = operation->get_matrix();
        }

        matrices.push_back(operation_mtx);


    }

    return matrices;

}



void Operation_block::add_u3_to_end(int target_qbit, bool Theta, bool Phi, bool Lambda) {

        // create the operation
        Operation* operation = static_cast<Operation*>(new U3( qbit_num, target_qbit, Theta, Phi, Lambda ));

        // adding the operation to the end of the list of operations
        add_operation_to_end( operation );
}

void Operation_block::add_u3_to_front(int target_qbit, bool Theta, bool Phi, bool Lambda) {

        // create the operation
        Operation* operation = static_cast<Operation*>(new U3( qbit_num, target_qbit, Theta, Phi, Lambda ));

        // adding the operation to the front of the list of operations
        add_operation_to_front( operation );

}

void Operation_block::add_cnot_to_end( int control_qbit, int target_qbit) {

        // new cnot operation
        Operation* operation = static_cast<Operation*>(new CNOT(qbit_num, control_qbit, target_qbit ));

        // append the operation to the list
        add_operation_to_end(operation);

}



void Operation_block::add_cnot_to_front( int control_qbit, int target_qbit) {

        // new cnot operation
        Operation* operation = static_cast<Operation*>(new CNOT(qbit_num, control_qbit, target_qbit ));

        // put the operation to tghe front of the list
        add_operation_to_front(operation);

}

void Operation_block::add_operations_to_end( vector<Operation*> operations_in) {

        for(std::vector<Operation*>::iterator it = operations_in.begin(); it != operations_in.end(); ++it) {
            add_operation_to_end( *it );
        }

}


void Operation_block::add_operations_to_front( vector<Operation*>  operations_in) {

        // adding operations in reversed order!!
        for(std::vector<Operation*>::iterator it = operations_in.end(); it != operations_in.begin(); --it) {
            add_operation_to_front( *it );
        }

}


void Operation_block::add_operation_to_end( Operation* operation ) {

        //set the number of qubit in the operation
        operation->set_qbit_num( qbit_num );

        // append the operation to the list
        operations.push_back(operation);


        // increase the number of parameters by the number of parameters
        parameter_num = parameter_num + operation->get_parameter_num();

        // increase the number of layers if necessary
        if (operation->get_type() == BLOCK_OPERATION) {
            layer_num = layer_num + 1;
        }

}

 void Operation_block::add_operation_to_front( Operation* operation) {


        // set the number of qubit in the operation
        operation->set_qbit_num( qbit_num );

        operations.insert( operations.begin(), operation);

        // increase the number of U3 gate parameters by the number of parameters
        parameter_num = parameter_num + operation->get_parameter_num();

        // increase the number of layers if necessary
        if (operation->get_type() == BLOCK_OPERATION) {
            layer_num = layer_num + 1;
        }

}



gates_num Operation_block::get_gate_nums() {

        gates_num gate_nums;

        gate_nums.u3      = 0;
        gate_nums.cnot    = 0;
        gate_nums.general = 0;

        for(std::vector<Operation*>::iterator it = operations.begin(); it != operations.end(); ++it) {
            // get the specific operation or block of operations
            Operation* operation = *it;

            if (operation->get_type() == BLOCK_OPERATION) {
                Operation_block* block_operation = static_cast<Operation_block*>(operation);
                gates_num gate_nums_loc = block_operation->get_gate_nums();
                gate_nums.u3   = gate_nums.u3 + gate_nums_loc.u3;
                gate_nums.cnot = gate_nums.cnot + gate_nums_loc.cnot;
            }
            else if (operation->get_type() == U3_OPERATION) {
                gate_nums.u3   = gate_nums.u3 + 1;
            }
            else if (operation->get_type() == CNOT_OPERATION) {
                gate_nums.cnot   = gate_nums.cnot + 1;
            }
            else if (operation->get_type() == GENERAL_OPERATION) {
                gate_nums.general   = gate_nums.general + 1;
            }

        }


        return gate_nums;

}


int Operation_block::get_parameter_num() {
    return parameter_num;
}


int Operation_block::get_operation_num() {
    return operations.size();
}


void Operation_block::list_operations( const double* parameters, int start_index ) {

        printf( "\nThe operations in the list of operations:\n" );

        int operation_idx = start_index;
        int parameter_idx = parameter_num;

        for(int op_idx = operations.size()-1; op_idx>=0; op_idx--) {

            Operation* operation = operations[op_idx];

            if (operation->get_type() == CNOT_OPERATION) {
                CNOT* cnot_operation = static_cast<CNOT*>(operation);

                printf( "%dth operation: CNOT with control qubit: %d and target qubit: %d\n", operation_idx, cnot_operation->get_control_qbit(), cnot_operation->get_target_qbit() );
                operation_idx = operation_idx + 1;
            }
            else if (operation->get_type() == U3_OPERATION) {

                // definig the U3 parameters
                double vartheta;
                double varphi;
                double varlambda;

                // get the inverse parameters of the U3 rotation

                U3* u3_operation = static_cast<U3*>(operation);

                if ((u3_operation->get_parameter_num() == 1) && u3_operation->is_theta_parameter()) {
                    vartheta = std::fmod( parameters[parameter_idx-1], 4*M_PI);
                    varphi = 0;
                    varlambda =0;
                    parameter_idx = parameter_idx - 1;

                }
                else if ((u3_operation->get_parameter_num() == 1) && u3_operation->is_phi_parameter()) {
                    vartheta = 0;
                    varphi = std::fmod( parameters[ parameter_idx-1 ], 2*M_PI);
                    varlambda =0;
                    parameter_idx = parameter_idx - 1;
                }
                else if ((u3_operation->get_parameter_num() == 1) && u3_operation->is_lambda_parameter()) {
                    vartheta = 0;
                    varphi =  0;
                    varlambda = std::fmod( parameters[ parameter_idx-1 ], 2*M_PI);
                    parameter_idx = parameter_idx - 1;
                }
                else if ((u3_operation->get_parameter_num() == 2) && u3_operation->is_theta_parameter() && u3_operation->is_phi_parameter() ) {
                    vartheta = std::fmod( parameters[ parameter_idx-2 ], 4*M_PI);
                    varphi = std::fmod( parameters[ parameter_idx-1 ], 2*M_PI);
                    varlambda = 0;
                    parameter_idx = parameter_idx - 2;
                }
                else if ((u3_operation->get_parameter_num() == 2) && u3_operation->is_theta_parameter() && u3_operation->is_lambda_parameter() ) {
                    vartheta = std::fmod( parameters[ parameter_idx-2 ], 4*M_PI);
                    varphi = 0;
                    varlambda = std::fmod( parameters[ parameter_idx-1 ], 2*M_PI);
                    parameter_idx = parameter_idx - 2;
                }
                else if ((u3_operation->get_parameter_num() == 2) && u3_operation->is_phi_parameter() && u3_operation->is_lambda_parameter() ) {
                    vartheta = 0;
                    varphi = std::fmod( parameters[ parameter_idx-2], 2*M_PI);
                    varlambda = std::fmod( parameters[ parameter_idx-1 ], 2*M_PI);
                    parameter_idx = parameter_idx - 2;
                }
                else if ((u3_operation->get_parameter_num() == 3)) {
                    vartheta = std::fmod( parameters[ parameter_idx-3 ], 4*M_PI);
                    varphi = std::fmod( parameters[ parameter_idx-2 ], 2*M_PI);
                    varlambda = std::fmod( parameters[ parameter_idx-1 ], 2*M_PI);
                    parameter_idx = parameter_idx - 3;
                }

//                message = message + "U3 on target qubit %d with parameters theta = %f, phi = %f and lambda = %f";
                printf("%dth operation: U3 on target qubit: %d and with parameters theta = %f, phi = %f and lambda = %f\n", operation_idx, u3_operation->get_target_qbit(), vartheta, varphi, varlambda );
                operation_idx = operation_idx + 1;

            }
            else if (operation->get_type() == BLOCK_OPERATION) {
                Operation_block* block_operation = static_cast<Operation_block*>(operation);
                const double* parameters_layer = parameters + parameter_idx - operation->get_parameter_num();
                block_operation->list_operations( parameters_layer, operation_idx );
                parameter_idx = parameter_idx - block_operation->get_parameter_num();
                operation_idx = operation_idx + block_operation->get_operation_num();
            }

        }

}


void Operation_block::reorder_qubits( vector<int>  qbit_list) {

    for(std::vector<Operation*>::iterator it = operations.begin(); it != operations.end(); ++it) {

        Operation* operation = *it;

        if (operation->get_type() == CNOT_OPERATION) {
            CNOT* cnot_operation = static_cast<CNOT*>(operation);
            cnot_operation->reorder_qubits( qbit_list );
         }
         else if (operation->get_type() == U3_OPERATION) {
             U3* u3_operation = static_cast<U3*>(operation);
             u3_operation->reorder_qubits( qbit_list );
         }
         else if (operation->get_type() == BLOCK_OPERATION) {
             Operation_block* block_operation = static_cast<Operation_block*>(operation);
             block_operation->reorder_qubits( qbit_list );
         }


    }

}



std::vector<int> Operation_block::get_involved_qubits() {

    std::vector<int> involved_qbits;

    int qbit;


    for(std::vector<Operation*>::iterator it = operations.begin(); it != operations.end(); ++it) {

        Operation* operation = *it;

        qbit = operation->get_target_qbit();
        if (qbit != -1) {
            add_unique_elelement( involved_qbits, qbit );
        }


        qbit = operation->get_control_qbit();
        if (qbit != -1) {
            add_unique_elelement( involved_qbits, qbit );
        }

    }

    return involved_qbits;
}


std::vector<Operation*> Operation_block::get_operations() {
    return operations;
}


void Operation_block::combine(Operation_block* op_block) {

    // getting the list of operations
    std::vector<Operation*> operations_in = op_block->get_operations();

    for(std::vector<Operation*>::iterator it = (operations_in).begin(); it != (operations_in).end(); ++it) {
        Operation* op = *it;

        if (op->get_type() == CNOT_OPERATION) {
            CNOT* cnot_op = static_cast<CNOT*>( op );
            CNOT* cnot_op_cloned = cnot_op->clone();
            Operation* op_cloned = static_cast<Operation*>( cnot_op_cloned );
            add_operation_to_end(op_cloned);
        }
        else if (op->get_type() == U3_OPERATION) {
            U3* u3_op = static_cast<U3*>( op );
            U3* u3_op_cloned = u3_op->clone();
            Operation* op_cloned = static_cast<Operation*>( u3_op_cloned );
            add_operation_to_end( op_cloned );
        }
        else if (op->get_type() == BLOCK_OPERATION) {
            Operation_block* block_op = static_cast<Operation_block*>( op );
            Operation_block* block_op_cloned = block_op->clone();
            Operation* op_cloned = static_cast<Operation*>( block_op_cloned );
            add_operation_to_end( op_cloned );
        }
        else if (op->get_type() == GENERAL_OPERATION) {
            Operation* op_cloned = op->clone();
            add_operation_to_end( op_cloned );
        }

    }

}


void Operation_block::set_qbit_num( int qbit_num_in ) {

    // setting the number of qubits
    Operation::set_qbit_num(qbit_num_in);

    // setting the number of qubit in the operations
    for(std::vector<Operation*>::iterator it = operations.begin(); it != operations.end(); ++it) {
        Operation* op = *it;

        if (op->get_type() == CNOT_OPERATION) {
            CNOT* cnot_op = static_cast<CNOT*>( op );
            cnot_op->set_qbit_num( qbit_num_in );
        }
        else if (op->get_type() == U3_OPERATION) {
            U3* u3_op = static_cast<U3*>( op );
            u3_op->set_qbit_num( qbit_num_in );
        }
        else if (op->get_type() == BLOCK_OPERATION) {
            Operation_block* block_op = static_cast<Operation_block*>( op );
            block_op->set_qbit_num( qbit_num_in );
        }
        else if (op->get_type() == GENERAL_OPERATION) {
            op->set_qbit_num( qbit_num_in );
        }
    }
}


Operation_block* Operation_block::clone() {

    // creatign new instance of class Operation_block
    Operation_block* ret = new Operation_block( qbit_num );

    // extracting the operations from the current class
    if (extract_operations( ret ) != 0 ) {
        printf("Operation_block::clone(): extracting operations was not succesfull\n");
        exit(-1);
    };

    return ret;

}


int Operation_block::extract_operations( Operation_block* op_block ) {

    op_block->release_operations();

    for ( std::vector<Operation*>::iterator it=operations.begin(); it != operations.end(); ++it ) {
        Operation* op = *it;

        if (op->get_type() == CNOT_OPERATION) {
            CNOT* cnot_op = static_cast<CNOT*>( op );
            CNOT* cnot_op_cloned = cnot_op->clone();
            Operation* op_cloned = static_cast<Operation*>( cnot_op_cloned );
            op_block->add_operation_to_end( op_cloned );
        }
        else if (op->get_type() == U3_OPERATION) {
            U3* u3_op = static_cast<U3*>( op );
            U3* u3_op_cloned = u3_op->clone();
            Operation* op_cloned = static_cast<Operation*>( u3_op_cloned );
            op_block->add_operation_to_end( op_cloned );
        }
        else if (op->get_type() == BLOCK_OPERATION) {
            Operation_block* block_op = static_cast<Operation_block*>( op );
            Operation_block* block_op_cloned = block_op->clone();
            Operation* op_cloned = static_cast<Operation*>( block_op_cloned );
            op_block->add_operation_to_end( op_cloned );
        }
        else if (op->get_type() == GENERAL_OPERATION) {
            Operation* op_cloned = op->clone();
            op_block->add_operation_to_end( op_cloned );
        }

    }

    return 0;

}