Decomposition_Base.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 DECOMPOSITION_BASE_H
#define DECOMPOSITION_BASE_H


#include "Gates_block.h"
#include "CZ.h"
#include "CH.h"
#include "CNOT.h"
#include "CROT.h"
#include "R.h"
#include "U3.h"
#include "RX.h"
#include "H.h"
#include "X.h"
#include "Y.h"
#include "Z.h"
#include "SX.h"
#include "RY.h"
#include "CRY.h"
#include "RZ.h"
#include "SYC.h"
#include "Adaptive.h"
#include <map>
#include <cstdlib>
#include <time.h>
#include <ctime>
#include <cfloat>
#include <limits>
#include <tbb/cache_aligned_allocator.h>

#include "config_element.h"

#include <random>

typedef enum guess_type {ZEROS, RANDOM, CLOSE_TO_ZERO} guess_type;

#ifndef OPENBLAS_CONST
# define OPENBLAS_CONST const
#endif
#if defined(OS_WINDOWS) && defined(__64BIT__)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
typedef BLASLONG blasint;
#if defined(OS_WINDOWS) && defined(__64BIT__)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif

extern "C" double cblas_dznrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX);

class Decomposition_Base : public Gates_block {


public:
  
    int optimization_block;

    static std::map<int,int> max_layer_num_def;

    double optimization_tolerance;
    
    QGD_Complex16 global_phase_factor;
    
    std::string project_name;

    std::map<std::string, Config_Element> config;


protected:

    std::map<int,int> max_layer_num;

    std::map<int,int> iteration_loops;

    Matrix Umtx;

    Matrix_float Umtx_float;

    Matrix_real optimized_parameters_mtx;

    Matrix_real_float optimized_parameters_mtx_float;

    bool use_float;

    void sync_optimized_parameters_float();

    //double* optimized_parameters;

    bool decomposition_finalized;

    double decomposition_error;

    int finalizing_gates_num;

    int finalizing_parameter_num;

    volatile double current_minimum;

    double global_target_minimum;

    bool optimization_problem_solved;

    int max_outer_iterations;

    guess_type initial_guess;

    int num_threads;

    double convergence_threshold;
    

    std::mt19937 gen; 



public:

Decomposition_Base();

Decomposition_Base( Matrix Umtx_in, int qbit_num_in, std::map<std::string, Config_Element>& config_in, guess_type initial_guess_in);

Decomposition_Base( Matrix_float Umtx_in, int qbit_num_in, std::map<std::string, Config_Element>& config_in, guess_type initial_guess_in);

virtual ~Decomposition_Base();


void set_optimization_blocks( int optimization_block_in );

void set_max_iteration( int max_outer_iterations_in);


void list_gates( int start_index );


void solve_optimization_problem( double* solution_guess, int solution_guess_num );


virtual void solve_layer_optimization_problem( int num_of_parameters, Matrix_real solution_guess_gsl);



virtual double optimization_problem( const double* parameters );

bool check_optimization_solution();


Matrix get_Umtx();

Matrix_float get_Umtx_float();

bool get_use_float() const;

int get_Umtx_size();

Matrix_real get_optimized_parameters();

Matrix_real_float get_optimized_parameters_float();

void get_optimized_parameters( double* ret );


void set_optimized_parameters( double* parameters, int num_of_parameters );


Matrix get_decomposed_matrix();


Matrix apply_gate( Matrix& gate_mtx, Matrix& input_matrix );

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

int set_max_layer_num( int n, int max_layer_num_in );

int set_max_layer_num( std::map<int, int> max_layer_num_in );


int set_iteration_loops( int n, int iteration_loops_in );

int set_iteration_loops( std::map<int, int> iteration_loops_in );


static void Init_max_layer_num();


void set_optimization_tolerance( double tolerance_in );


void set_convergence_threshold( double convergence_threshold_in );


double get_decomposition_error( );


double get_current_minimum( );

std::string get_project_name();
void set_project_name(std::string& project_name_new);

void calculate_new_global_phase_factor( QGD_Complex16 global_phase_factor_new );

QGD_Complex16 get_global_phase_factor( );

void set_global_phase(double new_global_phase);


void apply_global_phase_factor(QGD_Complex16 global_phase_factor, Matrix& u3_gate);

void apply_global_phase_factor();

void export_unitary(std::string& filename);
Matrix import_unitary_from_binary(std::string& filename);


int get_parallel_configuration();


void set_qbit_num( int qbit_num_in );



};
#endif //DECOMPOSITION_BASE