python_interface.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/python_interface.h"
#include "qgd/N_Qubit_Decomposition.h"
#include "qgd/matrix.h"


extern "C" {


void* iface_new_N_Qubit_Decomposition( double* mtx_real, double* mtx_imag, int qbit_num, bool optimize_layer_num, int initial_guess_num ) {

    int matrix_size = Power_of_2(qbit_num);

    // combining real and imaginary parts of the matrix inti MKL complex matrix
    int element_num = matrix_size*matrix_size;
    Matrix Umtx = Matrix(matrix_size, matrix_size);

    //#pragma omp parallel for
    for(int idx = 0; idx < element_num; idx++) {
        Umtx[idx].real = mtx_real[idx];
        Umtx[idx].imag = mtx_imag[idx];
    }

    // setting the initial guess type
    guess_type initial_guess;
    if ( initial_guess_num==0 ) {
        initial_guess = ZEROS;
    }
    else if ( initial_guess_num==1 ) {
        initial_guess = RANDOM;
    }
    else if ( initial_guess_num==2 ) {
        initial_guess = CLOSE_TO_ZERO;
    }
    else {
        printf("Wrong initial guess\n");
        exit(-1);
    }

    // creating an instance of class N_Qubit_decomposition
    N_Qubit_Decomposition* instance = new N_Qubit_Decomposition( Umtx, qbit_num, optimize_layer_num, initial_guess );

    return (void*)instance;


}



int iface_start_decomposition( void* ptr ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);

    instance->start_decomposition(true, true);

    return 0;

}

int iface_delete_N_Qubit_Decomposition( void* ptr ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);


    delete instance;

    return 0;

}



int iface_set_identical_blocks( void* ptr, int qbit, int identical_blocks ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);
    return instance->set_identical_blocks( qbit, identical_blocks );

}

int iface_set_iteration_loops( void* ptr, int qbit, int iteration_loops ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);
    return instance->set_iteration_loops( qbit, iteration_loops );

}

int iface_set_max_layer_num( void* ptr, int qbit, int max_layer_num ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);
    return instance->set_max_layer_num( qbit, max_layer_num );

}

void iface_list_operations( void* ptr, int start_index ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);
    return instance->list_operations( start_index );

}

int iface_get_operation_num( void* ptr ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);
    return instance->get_operation_num();

}



int iface_get_operation( void* ptr, int n, int &op_type, int &target_qbit, int &control_qbit, double* parameters ) {

    operation_type type;
//printf("a %f, %f, %f\n", parameters[0], parameters[1], parameters[2] );
    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);
    int ret =  instance->get_operation( n, type, target_qbit, control_qbit, parameters );
//printf("b %f, %f, %f\n", parameters[0], parameters[1], parameters[2] );
    op_type = type;

    return ret;


}


int iface_set_verbose( void* ptr, bool verbose ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);
    instance->set_verbose( verbose );

    return 0;

}


int iface_set_optimalization_block( void* ptr, int optimalization_block ) {

    N_Qubit_Decomposition* instance = reinterpret_cast<N_Qubit_Decomposition*>(ptr);
    instance->set_optimization_blocks( optimalization_block );

    return 0;

}

} // end extern C